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

NLP入门（五）用深度学习实现命名实体识别（NER）

作者：运维做开发 | 2024-07-05 02:22:56

赞

踩

b-org o b-misc o o o b-misc o o

前言

  在文章：NLP入门（四）命名实体识别（NER）中，笔者介绍了两个实现命名实体识别的工具——NLTK和Stanford NLP。在本文中，我们将会学习到如何使用深度学习工具来自己一步步地实现NER，只要你坚持看完，就一定会很有收获的。
  OK，话不多说，让我们进入正题。
  几乎所有的NLP都依赖一个强大的语料库，本项目实现NER的语料库如下(文件名为train.txt，一共42000行，这里只展示前15行，可以在文章最后的Github地址下载该语料库)：

played on Monday ( home team in CAPS ) :
VBD IN NNP ( NN NN IN NNP ) :
O O O O O O O O O O
American League
NNP NNP
B-MISC I-MISC
Cleveland 2 DETROIT 1
NNP CD NNP CD
B-ORG O B-ORG O
BALTIMORE 12 Oakland 11 ( 10 innings )
VB CD NNP CD ( CD NN )
B-ORG O B-ORG O O O O O
TORONTO 5 Minnesota 3
TO CD NNP CD
B-ORG O B-ORG O
......

简单介绍下该语料库的结构：该语料库一共42000行，每三行为一组，其中，第一行为英语句子，第二行为每个句子的词性（关于英语单词的词性，可参考文章：NLP入门（三）词形还原（Lemmatization）），第三行为NER系统的标注，具体的含义会在之后介绍。
  我们的NER项目的名称为DL_4_NER，结构如下：

NER项目的名称

项目中每个文件的功能如下：

  • utils.py: 项目配置及数据导入
  • data_processing.py: 数据探索
  • Bi_LSTM_Model_training.py: 模型创建及训练
  • Bi_LSTM_Model_predict.py: 对新句子进行NER预测

  接下来，笔者将结合代码文件，分部介绍该项目的步骤，当所有步骤介绍完毕后，我们的项目就结束了，而你，也就知道了如何用深度学习实现命名实体识别（NER）。
  Let's begin!

项目配置

  第一步，是项目的配置及数据导入，在utils.py文件中实现，完整的代码如下：

  1. # -*- coding: utf-8 -*-
  2. import numpy as np
  3. import pandas as pd
  4.  
  5. # basic settings for DL_4_NER Project
  6. BASE_DIR = "F://NERSystem"
  7. CORPUS_PATH = "%s/train.txt" % BASE_DIR
  8.  
  9. KERAS_MODEL_SAVE_PATH = '%s/Bi-LSTM-4-NER.h5' % BASE_DIR
  10. WORD_DICTIONARY_PATH = '%s/word_dictionary.pk' % BASE_DIR
  11. InVERSE_WORD_DICTIONARY_PATH = '%s/inverse_word_dictionary.pk' % BASE_DIR
  12. LABEL_DICTIONARY_PATH = '%s/label_dictionary.pk' % BASE_DIR
  13. OUTPUT_DICTIONARY_PATH = '%s/output_dictionary.pk' % BASE_DIR
  14.  
  15. CONSTANTS = [
  16.              KERAS_MODEL_SAVE_PATH,
  17.              InVERSE_WORD_DICTIONARY_PATH,
  18.              WORD_DICTIONARY_PATH,
  19.              LABEL_DICTIONARY_PATH,
  20.              OUTPUT_DICTIONARY_PATH
  21.              ]
  22.  
  23. # load data from corpus to from pandas DataFrame
  24. def load_data():
  25.     with open(CORPUS_PATH, 'r') as f:
  26.         text_data = [text.strip() for text in f.readlines()]
  27.     text_data = [text_data[k].split('\t') for k in range(0, len(text_data))]
  28.     index = range(0, len(text_data), 3)
  29.  
  30.     # Transforming data to matrix format for neural network
  31.     input_data = list()
  32.     for i in range(1, len(index) - 1):
  33.         rows = text_data[index[i-1]:index[i]]
  34.         sentence_no = np.array([i]*len(rows[0]), dtype=str)
  35.         rows.append(sentence_no)
  36.         rows = np.array(rows).T
  37.         input_data.append(rows)
  38.  
  39.     input_data = pd.DataFrame(np.concatenate([item for item in input_data]),\
  40.                                columns=['word', 'pos', 'tag', 'sent_no'])
  41.  
  42.     return input_data
'
运行

在该代码中，先是设置了语料库文件的路径CORPUS_PATH，KERAS模型保存路径KERAS_MODEL_SAVE_PATH，以及在项目过程中会用到的三个字典的保存路径（以pickle文件形式保存）WORD_DICTIONARY_PATH，LABEL_DICTIONARY_PATH， OUTPUT_DICTIONARY_PATH。然后是load_data()函数，它将语料库中的文本以Pandas中的DataFrame结构展示出来，该数据框的前30行如下：

  1.          word  pos     tag sent_no
  2. 0      played  VBD       O       1
  3. 1          on   IN       O       1
  4. 2      Monday  NNP       O       1
  5. 3           (    (       O       1
  6. 4        home   NN       O       1
  7. 5        team   NN       O       1
  8. 6          in   IN       O       1
  9. 7        CAPS  NNP       O       1
  10. 8           )    )       O       1
  11. 9           :    :       O       1
  12. 10   American  NNP  B-MISC       2
  13. 11     League  NNP  I-MISC       2
  14. 12  Cleveland  NNP   B-ORG       3
  15. 13          2   CD       O       3
  16. 14    DETROIT  NNP   B-ORG       3
  17. 15          1   CD       O       3
  18. 16  BALTIMORE   VB   B-ORG       4
  19. 17         12   CD       O       4
  20. 18    Oakland  NNP   B-ORG       4
  21. 19         11   CD       O       4
  22. 20          (    (       O       4
  23. 21         10   CD       O       4
  24. 22    innings   NN       O       4
  25. 23          )    )       O       4
  26. 24    TORONTO   TO   B-ORG       5
  27. 25          5   CD       O       5
  28. 26  Minnesota  NNP   B-ORG       5
  29. 27          3   CD       O       5
  30. 28  Milwaukee  NNP   B-ORG       6
  31. 29          3   CD       O       6

在该数据框中，word这一列表示文本语料库中的单词，pos这一列表示该单词的词性，tag这一列表示NER的标注，sent_no这一列表示该单词在第几个句子中。

数据探索

  接着，第二步是数据探索，即对输入的数据（input_data）进行一些数据review，完整的代码（data_processing.py）如下:

  1. # -*- coding: utf-8 -*-
  2.  
  3. import pickle
  4. import numpy as np
  5. from collections import Counter
  6. from itertools import accumulate
  7. from operator import itemgetter
  8. import matplotlib.pyplot as plt
  9. import matplotlib as mpl
  10. from utils import BASE_DIR, CONSTANTS, load_data
  11.  
  12. # 设置matplotlib绘图时的字体
  13. mpl.rcParams['font.sans-serif']=['SimHei']
  14.  
  15. # 数据查看
  16. def data_review():
  17.  
  18.     # 数据导入
  19.     input_data = load_data()
  20.  
  21.     # 基本的数据review
  22.     sent_num = input_data['sent_no'].astype(np.int).max()
  23.     print("一共有%s个句子。\n"%sent_num)
  24.  
  25.     vocabulary = input_data['word'].unique()
  26.     print("一共有%d个单词。"%len(vocabulary))
  27.     print("前10个单词为：%s.\n"%vocabulary[:11])
  28.  
  29.     pos_arr = input_data['pos'].unique()
  30.     print("单词的词性列表：%s.\n"%pos_arr)
  31.  
  32.     ner_tag_arr = input_data['tag'].unique()
  33.     print("NER的标注列表：%s.\n" % ner_tag_arr)
  34.  
  35.     df = input_data[['word', 'sent_no']].groupby('sent_no').count()
  36.     sent_len_list = df['word'].tolist()
  37.     print("句子长度及出现频数字典：\n%s." % dict(Counter(sent_len_list)))
  38.  
  39.     # 绘制句子长度及出现频数统计图
  40.     sort_sent_len_dist = sorted(dict(Counter(sent_len_list)).items(), key=itemgetter(0))
  41.     sent_no_data = [item[0] for item in sort_sent_len_dist]
  42.     sent_count_data = [item[1] for item in sort_sent_len_dist]
  43.     plt.bar(sent_no_data, sent_count_data)
  44.     plt.title("句子长度及出现频数统计图")
  45.     plt.xlabel("句子长度")
  46.     plt.ylabel("句子长度出现的频数")
  47.     plt.savefig("%s/句子长度及出现频数统计图.png" % BASE_DIR)
  48.     plt.close()
  49.  
  50.     # 绘制句子长度累积分布函数(CDF)
  51.     sent_pentage_list = [(count/sent_num) for count in accumulate(sent_count_data)]
  52.  
  53.     # 寻找分位点为quantile的句子长度
  54.     quantile = 0.9992
  55.     #print(list(sent_pentage_list))
  56.     for length, per in zip(sent_no_data, sent_pentage_list):
  57.         if round(per, 4) == quantile:
  58.             index = length
  59.             break
  60.     print("\n分位点为%s的句子长度:%d." % (quantile, index))
  61.  
  62.     # 绘制CDF
  63.     plt.plot(sent_no_data, sent_pentage_list)
  64.     plt.hlines(quantile, 0, index, colors="c", linestyles="dashed")
  65.     plt.vlines(index, 0, quantile, colors="c", linestyles="dashed")
  66.     plt.text(0, quantile, str(quantile))
  67.     plt.text(index, 0, str(index))
  68.     plt.title("句子长度累积分布函数图")
  69.     plt.xlabel("句子长度")
  70.     plt.ylabel("句子长度累积频率")
  71.     plt.savefig("%s/句子长度累积分布函数图.png" % BASE_DIR)
  72.     plt.close()
  73.  
  74. # 数据处理
  75. def data_processing():
  76.     # 数据导入
  77.     input_data = load_data()
  78.  
  79.     # 标签及词汇表
  80.     labels, vocabulary = list(input_data['tag'].unique()), list(input_data['word'].unique())
  81.  
  82.     # 字典列表
  83.     word_dictionary = {word: i+1 for i, word in enumerate(vocabulary)}
  84.     inverse_word_dictionary = {i+1: word for i, word in enumerate(vocabulary)}
  85.     label_dictionary = {label: i+1 for i, label in enumerate(labels)}
  86.     output_dictionary = {i+1: labels for i, labels in enumerate(labels)}
  87.  
  88.     dict_list = [word_dictionary, inverse_word_dictionary,label_dictionary, output_dictionary]
  89.  
  90.     # 保存为pickle形式
  91.     for dict_item, path in zip(dict_list, CONSTANTS[1:]):
  92.         with open(path, 'wb') as f:
  93.             pickle.dump(dict_item, f)
  94.  
  95. #data_review()

调用data_review()函数，输出的结果如下：

  1. 一共有13998个句子。
  2.  
  3. 一共有24339个单词。
  4. 前10个单词为：['played' 'on' 'Monday' '(' 'home' 'team' 'in' 'CAPS' ')' ':' 'American'].
  5.  
  6. 单词的词性列表：['VBD' 'IN' 'NNP' '(' 'NN' ')' ':' 'CD' 'VB' 'TO' 'NNS' ',' 'VBP' 'VBZ'
  7.  '.' 'VBG' 'PRP$' 'JJ' 'CC' 'JJS' 'RB' 'DT' 'VBN' '"' 'PRP' 'WDT' 'WRB'
  8.  'MD' 'WP' 'POS' 'JJR' 'WP$' 'RP' 'NNPS' 'RBS' 'FW' '$' 'RBR' 'EX' "''"
  9.  'PDT' 'UH' 'SYM' 'LS' 'NN|SYM'].
  10.  
  11. NER的标注列表：['O' 'B-MISC' 'I-MISC' 'B-ORG' 'I-ORG' 'B-PER' 'B-LOC' 'I-PER' 'I-LOC'
  12.  'sO'].
  13.  
  14. 句子长度及出现频数字典：
  15. {1: 177, 2: 1141, 3: 620, 4: 794, 5: 769, 6: 639, 7: 999, 8: 977, 9: 841, 10: 501, 11: 395, 12: 316, 13: 339, 14: 291, 15: 275, 16: 225, 17: 229, 18: 212, 19: 197, 20: 221, 21: 228, 22: 221, 23: 230, 24: 210, 25: 207, 26: 224, 27: 188, 28: 199, 29: 214, 30: 183, 31: 202, 32: 167, 33: 167, 34: 141, 35: 130, 36: 119, 37: 105, 38: 112, 39: 98, 40: 78, 41: 74, 42: 63, 43: 51, 44: 42, 45: 39, 46: 19, 47: 22, 48: 19, 49: 15, 50: 16, 51: 8, 52: 9, 53: 5, 54: 4, 55: 9, 56: 2, 57: 2, 58: 2, 59: 2, 60: 3, 62: 2, 66: 1, 67: 1, 69: 1, 71: 1, 72: 1, 78: 1, 80: 1, 113: 1, 124: 1}.
  16.  
  17. 分位点为0.9992的句子长度:60.

在该语料库中，一共有13998个句子，比预期的42000/3=14000个句子少两个。一个有24339个单词，单词量还是蛮大的，当然，这里对单词没有做任何处理，直接保留了语料库中的形式（后期可以继续优化）。单词的词性可以参考文章：NLP入门（三）词形还原（Lemmatization）。我们需要注意的是，NER的标注列表为['O' ,'B-MISC', 'I-MISC', 'B-ORG' ,'I-ORG', 'B-PER' ,'B-LOC' ,'I-PER', 'I-LOC','sO']，因此，本项目的NER一共分为四类：PER（人名），LOC（位置），ORG（组织）以及MISC，其中B表示开始，I表示中间，O表示单字词，不计入NER，sO表示特殊单字词。
  接下来，让我们考虑下句子的长度，这对后面的建模时填充的句子长度有有参考作用。句子长度及出现频数的统计图如下：

句子长度及出现频数统计图

可以看到，句子长度基本在60以下，当然，这也可以在输出的句子长度及出现频数字典中看到。那么，我们是否可以选在一个标准作为后面模型的句子填充的长度呢？答案是，利用出现频数的累计分布函数的分位点，在这里，我们选择分位点为0.9992,对应的句子长度为60，如下图：

句子长度累积分布函数图

  接着是数据处理函数data_processing()，它的功能主要是实现单词、标签字典，并保存为pickle文件形式，便于后续直接调用。

建模

  在第三步中，我们建立Bi-LSTM模型来训练训练，完整的Python代码（Bi_LSTM_Model_training.py）如下：

  1. # -*- coding: utf-8 -*-
  2. import pickle
  3. import numpy as np
  4. import pandas as pd
  5. from utils import BASE_DIR, CONSTANTS, load_data
  6. from data_processing import data_processing
  7. from keras.utils import np_utils, plot_model
  8. from keras.models import Sequential
  9. from keras.preprocessing.sequence import pad_sequences
  10. from keras.layers import Bidirectional, LSTM, Dense, Embedding, TimeDistributed
  11.  
  12.  
  13. # 模型输入数据
  14. def input_data_for_model(input_shape):
  15.  
  16.     # 数据导入
  17.     input_data = load_data()
  18.     # 数据处理
  19.     data_processing()
  20.     # 导入字典
  21.     with open(CONSTANTS[1], 'rb') as f:
  22.         word_dictionary = pickle.load(f)
  23.     with open(CONSTANTS[2], 'rb') as f:
  24.         inverse_word_dictionary = pickle.load(f)
  25.     with open(CONSTANTS[3], 'rb') as f:
  26.         label_dictionary = pickle.load(f)
  27.     with open(CONSTANTS[4], 'rb') as f:
  28.         output_dictionary = pickle.load(f)
  29.     vocab_size = len(word_dictionary.keys())
  30.     label_size = len(label_dictionary.keys())
  31.  
  32.     # 处理输入数据
  33.     aggregate_function = lambda input: [(word, pos, label) for word, pos, label in
  34.                                             zip(input['word'].values.tolist(),
  35.                                                 input['pos'].values.tolist(),
  36.                                                 input['tag'].values.tolist())]
  37.  
  38.     grouped_input_data = input_data.groupby('sent_no').apply(aggregate_function)
  39.     sentences = [sentence for sentence in grouped_input_data]
  40.  
  41.     x = [[word_dictionary[word[0]] for word in sent] for sent in sentences]
  42.     x = pad_sequences(maxlen=input_shape, sequences=x, padding='post', value=0)
  43.     y = [[label_dictionary[word[2]] for word in sent] for sent in sentences]
  44.     y = pad_sequences(maxlen=input_shape, sequences=y, padding='post', value=0)
  45.     y = [np_utils.to_categorical(label, num_classes=label_size + 1) for label in y]
  46.  
  47.     return x, y, output_dictionary, vocab_size, label_size, inverse_word_dictionary
  48.  
  49.  
  50. # 定义深度学习模型：Bi-LSTM
  51. def create_Bi_LSTM(vocab_size, label_size, input_shape, output_dim, n_units, out_act, activation):
  52.     model = Sequential()
  53.     model.add(Embedding(input_dim=vocab_size + 1, output_dim=output_dim,
  54.                         input_length=input_shape, mask_zero=True))
  55.     model.add(Bidirectional(LSTM(units=n_units, activation=activation,
  56.                                  return_sequences=True)))
  57.     model.add(TimeDistributed(Dense(label_size + 1, activation=out_act)))
  58.     model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
  59.     return model
  60.  
  61.  
  62. # 模型训练
  63. def model_train():
  64.  
  65.     # 将数据集分为训练集和测试集，占比为9:1
  66.     input_shape = 60
  67.     x, y, output_dictionary, vocab_size, label_size, inverse_word_dictionary = input_data_for_model(input_shape)
  68.     train_end = int(len(x)*0.9)
  69.     train_x, train_y = x[0:train_end], np.array(y[0:train_end])
  70.     test_x, test_y = x[train_end:], np.array(y[train_end:])
  71.  
  72.     # 模型输入参数
  73.     activation = 'selu'
  74.     out_act = 'softmax'
  75.     n_units = 100
  76.     batch_size = 32
  77.     epochs = 10
  78.     output_dim = 20
  79.  
  80.     # 模型训练
  81.     lstm_model = create_Bi_LSTM(vocab_size, label_size, input_shape, output_dim, n_units, out_act, activation)
  82.     lstm_model.fit(train_x, train_y, epochs=epochs, batch_size=batch_size, verbose=1)
  83.  
  84.     # 模型保存
  85.     model_save_path = CONSTANTS[0]
  86.     lstm_model.save(model_save_path)
  87.     plot_model(lstm_model, to_file='%s/LSTM_model.png' % BASE_DIR)
  88.  
  89.     # 在测试集上的效果
  90.     N = test_x.shape[0]  # 测试的条数
  91.     avg_accuracy = 0  # 预测的平均准确率
  92.     for start, end in zip(range(0, N, 1), range(1, N+1, 1)):
  93.         sentence = [inverse_word_dictionary[i] for i in test_x[start] if i != 0]
  94.         y_predict = lstm_model.predict(test_x[start:end])
  95.         input_sequences, output_sequences = [], []
  96.         for i in range(0, len(y_predict[0])):
  97.             output_sequences.append(np.argmax(y_predict[0][i]))
  98.             input_sequences.append(np.argmax(test_y[start][i]))
  99.  
  100.         eval = lstm_model.evaluate(test_x[start:end], test_y[start:end])
  101.         print('Test Accuracy: loss = %0.6f accuracy = %0.2f%%' % (eval[0], eval[1] * 100))
  102.         avg_accuracy += eval[1]
  103.         output_sequences = ' '.join([output_dictionary[key] for key in output_sequences if key != 0]).split()
  104.         input_sequences = ' '.join([output_dictionary[key] for key in input_sequences if key != 0]).split()
  105.         output_input_comparison = pd.DataFrame([sentence, output_sequences, input_sequences]).T
  106.         print(output_input_comparison.dropna())
  107.         print('#' * 80)
  108.  
  109.     avg_accuracy /= N
  110.     print("测试样本的平均预测准确率：%.2f%%." % (avg_accuracy * 100))
  111.  
  112. model_train()

在上面的代码中，先是通过input_data_for_model()函数来处理好进入模型的数据，其参数为input_shape，即填充句子时的长度。然后是创建Bi-LSTM模型create_Bi_LSTM()，模型的示意图如下：

Bi-LSTM模型示意图

最后，是在输入的数据上进行模型训练，将原始的数据分为训练集和测试集，占比为9:1，训练的周期为10次。

模型训练

  运行上述模型训练代码，一共训练10个周期，训练时间大概为500s，在训练集上的准确率达99%以上，在测试集上的平均准确率为95%以上。以下是最后几个测试集上的预测结果：

  1. ......(前面的输出已忽略)
  2. Test Accuracy: loss = 0.000986 accuracy = 100.00%
  3.           0      1      2
  4. 0   Cardiff  B-ORG  B-ORG
  5. 1         1      O      O
  6. 2  Brighton  B-ORG  B-ORG
  7. 3         0      O      O
  8. ################################################################################
  9.  
  10. 1/1 [==============================] - 0s 10ms/step
  11. Test Accuracy: loss = 0.000274 accuracy = 100.00%
  12.           0      1      2
  13. 0  Carlisle  B-ORG  B-ORG
  14. 1         0      O      O
  15. 2      Hull  B-ORG  B-ORG
  16. 3         0      O      O
  17. ################################################################################
  18.  
  19. 1/1 [==============================] - 0s 9ms/step
  20. Test Accuracy: loss = 0.000479 accuracy = 100.00%
  21.            0      1      2
  22. 0    Chester  B-ORG  B-ORG
  23. 1          1      O      O
  24. 2  Cambridge  B-ORG  B-ORG
  25. 3          1      O      O
  26. ################################################################################
  27.  
  28. 1/1 [==============================] - 0s 9ms/step
  29. Test Accuracy: loss = 0.003092 accuracy = 100.00%
  30.             0      1      2
  31. 0  Darlington  B-ORG  B-ORG
  32. 1           4      O      O
  33. 2     Swansea  B-ORG  B-ORG
  34. 3           1      O      O
  35. ################################################################################
  36.  
  37. 1/1 [==============================] - 0s 8ms/step
  38. Test Accuracy: loss = 0.000705 accuracy = 100.00%
  39.              0      1      2
  40. 0       Exeter  B-ORG  B-ORG
  41. 1            2      O      O
  42. 2  Scarborough  B-ORG  B-ORG
  43. 3            2      O      O
  44. ################################################################################
  45. 测试样本的平均预测准确率：95.55%.

  该模型在原始数据上的识别效果还是可以的。
  训练完模型后，BASE_DIR中的所有文件如下：

模型训练完后的所有文件截图

模型预测

  最后，也许是整个项目最为激动人心的时刻，因为，我们要在新数据集上测试模型的识别效果。预测新数据的识别结果的完整Python代码（Bi_LSTM_Model_predict.py）如下：

  1. # -*- coding: utf-8 -*-
  2. # Name entity recognition for new data
  3.  
  4. # Import the necessary modules
  5. import pickle
  6. import numpy as np
  7. from utils import CONSTANTS
  8. from keras.preprocessing.sequence import pad_sequences
  9. from keras.models import load_model
  10. from nltk import word_tokenize
  11.  
  12. # 导入字典
  13. with open(CONSTANTS[1], 'rb') as f:
  14.     word_dictionary = pickle.load(f)
  15. with open(CONSTANTS[4], 'rb') as f:
  16.     output_dictionary = pickle.load(f)
  17.  
  18. try:
  19.     # 数据预处理
  20.     input_shape = 60
  21.     sent = 'New York is the biggest city in America.'
  22.     new_sent = word_tokenize(sent)
  23.     new_x = [[word_dictionary[word] for word in new_sent]]
  24.     x = pad_sequences(maxlen=input_shape, sequences=new_x, padding='post', value=0)
  25.  
  26.     # 载入模型
  27.     model_save_path = CONSTANTS[0]
  28.     lstm_model = load_model(model_save_path)
  29.  
  30.     # 模型预测
  31.     y_predict = lstm_model.predict(x)
  32.  
  33.     ner_tag = []
  34.     for i in range(0, len(new_sent)):
  35.         ner_tag.append(np.argmax(y_predict[0][i]))
  36.  
  37.     ner = [output_dictionary[i] for i in ner_tag]
  38.     print(new_sent)
  39.     print(ner)
  40.  
  41.     # 去掉NER标注为O的元素
  42.     ner_reg_list = []
  43.     for word, tag in zip(new_sent, ner):
  44.         if tag != 'O':
  45.             ner_reg_list.append((word, tag))
  46.  
  47.     # 输出模型的NER识别结果
  48.     print("NER识别结果：")
  49.     if ner_reg_list:
  50.         for i, item in enumerate(ner_reg_list):
  51.             if item[1].startswith('B'):
  52.                 end = i+1
  53.                 while end <= len(ner_reg_list)-1 and ner_reg_list[end][1].startswith('I'):
  54.                     end += 1
  55.  
  56.                 ner_type = item[1].split('-')[1]
  57.                 ner_type_dict = {'PER': 'PERSON: ',
  58.                                 'LOC': 'LOCATION: ',
  59.                                 'ORG': 'ORGANIZATION: ',
  60.                                 'MISC': 'MISC: '
  61.                                 }
  62.                 print(ner_type_dict[ner_type],\
  63.                     ' '.join([item[0] for item in ner_reg_list[i:end]]))
  64.     else:
  65.         print("模型并未识别任何有效命名实体。")
  66.  
  67. except KeyError as err:
  68.     print("您输入的句子有单词不在词汇表中，请重新输入！")
  69.     print("不在词汇表中的单词为：%s." % err)

输出结果为：

  1. ['New', 'York', 'is', 'the', 'biggest', 'city', 'in', 'America', '.']
  2. ['B-LOC', 'I-LOC', 'O', 'O', 'O', 'O', 'O', 'B-LOC', 'O']
  3. NER识别结果：
  4. LOCATION:  New York
  5. LOCATION:  America

  接下来，再测试三个笔者自己想的句子：

输入为：

sent = 'James is a world famous actor, whose home is in London.'

输出结果为：

  1. ['James', 'is', 'a', 'world', 'famous', 'actor', ',', 'whose', 'home', 'is', 'in', 'London', '.']
  2. ['B-PER', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'B-LOC', 'O']
  3. NER识别结果：
  4. PERSON:  James
  5. LOCATION:  London

输入为：

sent = 'Oxford is in England, Jack is from here.'

输出为：

  1. ['Oxford', 'is', 'in', 'England', ',', 'Jack', 'is', 'from', 'here', '.']
  2. ['B-PER', 'O', 'O', 'B-LOC', 'O', 'B-PER', 'O', 'O', 'O', 'O']
  3. NER识别结果：
  4. PERSON:  Oxford
  5. LOCATION:  England
  6. PERSON:  Jack

输入为：

sent = 'I love Shanghai.'

输出为：

  1. ['I', 'love', 'Shanghai', '.']
  2. ['O', 'O', 'B-LOC', 'O']
  3. NER识别结果：
  4. LOCATION:  Shanghai

在上面的例子中，只有Oxford的识别效果不理想，模型将它识别为PERSON，其实应该是ORGANIZATION。

  接下来是三个来自CNN和wikipedia的句子：

输入为：

sent = "the US runs the risk of a military defeat by China or Russia"

输出为：

  1. ['the', 'US', 'runs', 'the', 'risk', 'of', 'a', 'military', 'defeat', 'by', 'China', 'or', 'Russia']
  2. ['O', 'B-LOC', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'B-LOC', 'O', 'B-LOC']
  3. NER识别结果：
  4. LOCATION:  US
  5. LOCATION:  China
  6. LOCATION:  Russia

输入为：

sent = "Home to the headquarters of the United Nations, New York is an important center for international diplomacy."

输出为：

  1. ['Home', 'to', 'the', 'headquarters', 'of', 'the', 'United', 'Nations', ',', 'New', 'York', 'is', 'an', 'important', 'center', 'for', 'international', 'diplomacy', '.']
  2. ['O', 'O', 'O', 'O', 'O', 'O', 'B-ORG', 'I-ORG', 'O', 'B-LOC', 'I-LOC', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']
  3. NER识别结果：
  4. ORGANIZATION:  United Nations
  5. LOCATION:  New York

输入为：

sent = "The United States is a founding member of the United Nations, World Bank, International Monetary Fund."

输出为:

  1. ['The', 'United', 'States', 'is', 'a', 'founding', 'member', 'of', 'the', 'United', 'Nations', ',', 'World', 'Bank', ',', 'International', 'Monetary', 'Fund', '.']
  2. ['O', 'B-LOC', 'I-LOC', 'O', 'O', 'O', 'O', 'O', 'O', 'B-ORG', 'I-ORG', 'O', 'B-ORG', 'I-ORG', 'O', 'B-ORG', 'I-ORG', 'I-ORG', 'O']
  3. NER识别结果：
  4. LOCATION:  United States
  5. ORGANIZATION:  United Nations
  6. ORGANIZATION:  World Bank
  7. ORGANIZATION:  International Monetary Fund

  这三个例子识别全部正确。

总结

  到这儿，笔者的这个项目就差不多了。我们有必要对这个项目做个总结。
  首先是这个项目的优点。它的优点在于能够让你一步步地实现NER，而且除了语料库，你基本熟悉了如何创建一个识别NER系统的步骤，同时，对深度学习模型及其应用也有了深刻理解。因此，好处是显而易见的。当然，在实际工作中，语料库的整理才是最耗费时间的，能够占到90%或者更多的时间，因此，有一个好的语料库你才能展开工作。
  接着讲讲这个项目的缺点。第一个，是语料库不够大，当然，约14000条句子也够了，但本项目没有对句子进行文本预处理，所以，有些单词的变形可能无法进入词汇表。第二个，缺少对新词的处理，一旦句子中出现一个新的单词，这个模型便无法处理，这是后期需要完善的地方。第三个，句子的填充长度为60，如果输入的句子长度大于60，则后面的部分将无法有效识别。
  因此，后续还有更多的工作需要去做，当然，做一个中文NER也是可以考虑的。
  本项目已上传Github,地址为 https://github.com/percent4/DL_4_NER 。：欢迎大家参考~

注意：本人现已开通微信公众号： Python爬虫与算法（微信号为：easy_web_scrape）， 欢迎大家关注哦~~

参考文献

  1. BOOK： Applied Natural Language Processing with Python， Taweh Beysolow II
  2. WEBSITE：https://github.com/Apress/applied-natural-language-processing-w-python
  3. WEBSITE: NLP入门（四）命名实体识别（NER）: https://www.jianshu.com/p/16e1f6a7aaef

转载于:https://www.cnblogs.com/jclian91/p/9970281.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/788903
推荐阅读
相关标签

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

  

闽ICP备14008679号