NLP-文本处理：语义角色标注（触发者、谓语、受事者、时间..）【基于“句子A的分词列表B”+“B的词性列表C”+“B与C的依存句法分析结果”】--＞关系抽取--＞知识图谱

柔光的暖阳◎ 2023-10-05 16:56 65阅读 0赞

一、LTP进行语义角色标注

  1. import os
  2. from pyltp import Segmentor, Postagger, Parser, NamedEntityRecognizer, SementicRoleLabeller
  3. # pip install pyltp -i https://pypi.tuna.tsinghua.edu.cn/simple 可以先下载好whl文件
  4. #LTP语言平台：http://ltp.ai/index.html
  5. #咱们使用的工具包,pyltp:https://pyltp.readthedocs.io/zh_CN/latest/api.html
  6. #LTP附录：https://ltp.readthedocs.io/zh_CN/latest/appendix.html#id3
  7. #安装方法：https://github.com/HIT-SCIR/pyltp
  8. class LtpParser:
  9.     def __init__(self):
  10.         LTP_DIR = "./ltp_data_v3.4.0"
  11.         self.segmentor = Segmentor()    # 分词
  12.         self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))
  14.         self.postagger = Postagger()    # 词性标注
  15.         self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
  17.         self.parser = Parser()  # 句法依存分析
  18.         self.parser.load(os.path.join(LTP_DIR, "parser.model"))
  20.         self.recognizer = NamedEntityRecognizer()   # 命名实体识别
  21.         self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
  23.         self.labeller = SementicRoleLabeller()  # 语义角色标注
  24.         self.labeller.load(os.path.join(LTP_DIR, 'pisrl_win.model'))
  26.     # 语义角色标注
  27.     def format_labelrole(self, words, postags):
  28.         print("分词----> words= {0}----len(words) = {1}".format(words, len(words)))
  29.         print("词性标注----> postags= {0}----len(postags) = {1}".format(postags, len(postags)))
  30.         arcs = self.parser.parse(words, postags)  # 建立依存句法分析树
  31.         roles = self.labeller.label(words, postags, arcs)
  32.         print("len(roles) = {0}----roles = {1}".format(len(roles), roles))
  33.         roles_dict = {
  34.     }
  35.         for role in roles:
  36.             print("谓语所在索引：role.index = {0}".format(role.index))
  37.             roles_dict[role.index] = {
  38.     arg.name:[arg.name,arg.range.start, arg.range.end] for arg in role.arguments}
  39.         # {6: {'A0': ['A0', 0, 2], 'TMP': ['TMP', 3, 3], 'LOC': ['LOC', 4, 5], 'A1': ['A1', 8, 8]}}
  40.         # 6：表示谓语（发表）所在序号；
  41.         # A0：表示“施事者、主体、触发者”，0,2分别表示A0所在的起始索引、终止索引（此句中有2个A0，分别是“奥巴马”、“克林顿”，索引范围是是0-2）
  42.         # TMP：表示“时间”，3, 3分别表示TMP所在的起始索引、终止索引（“昨晚”）
  43.         # LOC：表示“地点”，4, 5分别表示LOC所在的起始索引、终止索引（“在”,“白宫”）
  44.         # A1：表示“受事者”，8, 8分别表示LOC所在的起始索引、终止索引（“演说”）
  45.         print("语义角色标注---->roles_dict = {0}".format(roles_dict))
  46.         return roles_dict
  48.     '''parser主函数'''
  49.     def parser_main(self, sentence):
  50.         # 分词
  51.         words = list(self.segmentor.segment(sentence))
  52.         # 词性标注
  53.         postags = list(self.postagger.postag(words))
  54.         # 语义角色标注
  55.         roles_dict = self.format_labelrole(words, postags)
  57.         return words, postags, roles_dict
  60. if __name__ == '__main__':
  61.     parse = LtpParser()
  62.     sentence = '奥巴马与克林顿昨晚在白宫发表了演说'
  63.     words, postags, roles_dict = parse.parser_main(sentence)

输出结果：

  1. 分词----> words= ['奥巴马', '与', '克林顿', '昨晚', '在', '白宫', '发表', '了', '演说']----len(words) = 9
  2. 词性标注----> postags= ['nh', 'p', 'nh', 'nt', 'p', 'n', 'v', 'u', 'v']----len(postags) = 9
  3. len(roles) = 1----roles = <pyltp.SementicRoles object at 0x000002170D3CC210>
  4. 谓语所在索引：role.index = 6
  5. 语义角色标注---->roles_dict = {
  6.     6: {
  7.     'A0': ['A0', 0, 2], 'TMP': ['TMP', 3, 3], 'LOC': ['LOC', 4, 5], 'A1': ['A1', 8, 8]}}
  9. Process finished with exit code 0

二、“语义角色标注”结果分析：

{6: {'A0': ['A0', 0, 2], 'TMP': ['TMP', 3, 3], 'LOC': ['LOC', 4, 5], 'A1': ['A1', 8, 8]}}

  • 6：表示谓语（发表）所在序号；
  • A0：表示“施事者、主体、触发者”，0,2分别表示A0所在的起始索引、终止索引（此句中有2个A0，分别是“奥巴马”、“克林顿”，索引范围是是0-2）
  • TMP：表示“时间”，3, 3分别表示TMP所在的起始索引、终止索引（“昨晚”）
  • LOC：表示“地点”，4, 5分别表示LOC所在的起始索引、终止索引（“在”,“白宫”）
  • A1：表示“受事者”，8, 8分别表示LOC所在的起始索引、终止索引（“演说”）

三、关系抽取【三元组（Triple、主谓宾） 抽取】

  1. import os
  2. import re
  3. from pyltp import Segmentor, Postagger, Parser, NamedEntityRecognizer, SementicRoleLabeller
  4. # pip install pyltp -i https://pypi.tuna.tsinghua.edu.cn/simple 可以先下载好whl文件
  5. #LTP语言平台：http://ltp.ai/index.html
  6. #咱们使用的工具包,pyltp:https://pyltp.readthedocs.io/zh_CN/latest/api.html
  7. #LTP附录：https://ltp.readthedocs.io/zh_CN/latest/appendix.html#id3
  8. #安装方法：https://github.com/HIT-SCIR/pyltp
  11. class LtpParser:
  12.     def __init__(self):
  13.         LTP_DIR = "./ltp_data_v3.4.0"
  14.         self.segmentor = Segmentor()    # 分词
  15.         self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))
  17.         self.postagger = Postagger()    # 词性标注
  18.         self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
  20.         self.parser = Parser()  # 句法依存分析
  21.         self.parser.load(os.path.join(LTP_DIR, "parser.model"))
  23.         self.recognizer = NamedEntityRecognizer()   # 命名实体识别
  24.         self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
  26.         self.labeller = SementicRoleLabeller()  # 语义角色标注
  27.         self.labeller.load(os.path.join(LTP_DIR, 'pisrl_win.model'))
  29.     # 依存句法分析【为句子中的每个词语维护一个保存句法依存儿子节点的字典】
  30.     def build_parse_child_dict(self, words, postags): # words：分词后的结果；postags：词性标注后的结果；arcs：依存句法分析树
  31.         print("-" * 50, "依存句法分析：开始", "-" * 50)
  32.         child_dict_list = []
  33.         format_parse_list = []
  34.         arcs = self.parser.parse(words, postags)  # 建立依存句法分析树
  35.         print("分词列表：words = {}".format(words))
  36.         print("词性分析：postags = {}".format(postags))
  37.         rely_ids = [arc.head - 1 for arc in arcs]  # 提取该句话的每一个词的依存父节点id【0为ROOT，词语从1开始编号】: [2, 0, 2, 5, 8, 8, 6, 3] - 1 =  [1, -1, 1, 4, 7, 7, 5, 2]【此时 -1 表示ROOT】
  38.         print("各个词语所依赖的父节点：rely_ids = {0}".format(rely_ids))
  39.         heads = ['Root' if rely_id == -1 else words[rely_id] for rely_id in rely_ids]  # 匹配依存父节点词语
  40.         print("各个词语所依赖的父节点词语 = {0}".format(heads))
  41.         relations = [arc.relation for arc in arcs]  # 提取依存关系
  42.         print("各个词语与所依赖的父节点的依赖关系 = {0}".format(relations))
  44.         for word_index in range(len(words)):
  45.             print("\nword_index = {0}----word = {1}".format(word_index, words[word_index]))
  46.             child_dict = dict() # 每个词语与所有其他词语的关系字典
  47.             for arc_index in range(len(arcs)):  # arc_index==0时表示ROOT【还没进入“我想听一首迪哥的歌”语句】，arc_index==1时表示“我”
  48.                 # 当“依存句法分析树”遍历，遇到当前词语时，说明当前词语在依存句法分析树中与其他词语有依存关系
  49.                 if word_index == rely_ids[arc_index]:  # arcs[arc_index].head 表示arcs[arc_index]所代表的词语依存弧的父结点的索引。 ROOT 节点的索引是 0 ，第一个词开始的索引依次为1，2，3，···【“我”的索引为1】arc. relation 表示依存弧的关系。
  50.                     print("word_index = {0}----arc_index = {1}----rely_ids[arc_index] = {2}----relations[arc_index] = {3}".format(word_index, arc_index, rely_ids[arc_index], relations[arc_index]))
  51.                     if relations[arc_index] in child_dict:  # arcs[arc_index].relation表示arcs[arc_index]所代表的词语与父节点的依存关系(语法关系)
  52.                         child_dict[relations[arc_index]].append(arc_index) # 添加 child_dict = {'ATT': [4]}----> child_dict = {'ATT': [4, 5]}
  53.                     else:
  54.                         child_dict[relations[arc_index]] = [] # 新建
  55.                         child_dict[relations[arc_index]].append(arc_index)  # child_dict = {[]}----> child_dict = {'ATT': [4]}
  56.                     print("child_dict = {0}".format(child_dict))
  57.             child_dict_list.append(child_dict)# 每个词对应的依存关系父节点和其关系
  58.             print("child_dict_list = {0}".format(child_dict_list))
  59.         # 整合每个词语的句法依存关系
  60.         for i in range(len(words)):
  61.             a = [relations[i], words[i], i, postags[i], heads[i], rely_ids[i]-1, postags[rely_ids[i]-1]]
  62.             format_parse_list.append(a)
  63.         print("整合每个词语的句法依存关系---->format_parse_list = ", format_parse_list)
  64.         print("-" * 50, "依存句法分析：结束", "-" * 50)
  65.         return child_dict_list, format_parse_list
  67.     # 语义角色标注
  68.     def format_labelrole(self, words, postags):
  69.         print("-"*50, "语义角色标注：开始", "-"*50)
  70.         print("分词----> words= {0}----len(words) = {1}".format(words, len(words)))
  71.         print("词性标注----> postags= {0}----len(postags) = {1}".format(postags, len(postags)))
  72.         arcs = self.parser.parse(words, postags)  # 建立依存句法分析树
  73.         roles = self.labeller.label(words, postags, arcs)
  74.         print("len(roles) = {0}----roles = {1}".format(len(roles), roles))
  75.         roles_dict = {
  76.     }
  77.         for role in roles:
  78.             print("谓语所在索引：role.index = {0}".format(role.index))
  79.             roles_dict[role.index] = {
  80.     arg.name:[arg.name,arg.range.start, arg.range.end] for arg in role.arguments}
  81.         # {6: {'A0': ['A0', 0, 2], 'TMP': ['TMP', 3, 3], 'LOC': ['LOC', 4, 5], 'A1': ['A1', 8, 8]}}
  82.         # 6：表示谓语（发表）所在序号；
  83.         # A0：表示“施事者、主体、触发者”，0,2分别表示A0所在的起始索引、终止索引（此句中有2个A0，分别是“奥巴马”、“克林顿”，索引范围是是0-2）
  84.         # TMP：表示“时间”，3, 3分别表示TMP所在的起始索引、终止索引（“昨晚”）
  85.         # LOC：表示“地点”，4, 5分别表示LOC所在的起始索引、终止索引（“在”,“白宫”）
  86.         # A1：表示“受事者”，8, 8分别表示LOC所在的起始索引、终止索引（“演说”）
  87.         print("语义角色标注---->roles_dict = {0}".format(roles_dict))
  88.         print("-" * 50, "语义角色标注：结束", "-" * 50)
  89.         return roles_dict
  91.     # parser主函数
  92.     def parser_main(self, sentence):
  93.         # 分词
  94.         words = list(self.segmentor.segment(sentence))
  95.         # 词性标注
  96.         postags = list(self.postagger.postag(words))
  97.         # 依存句法分析
  98.         child_dict_list, format_parse_list = self.build_parse_child_dict(words, postags)
  99.         # 语义角色标注
  100.         roles_dict = self.format_labelrole(words, postags)
  102.         return words, postags, child_dict_list, format_parse_list, roles_dict
  104. # 关系抽取类
  105. class TripleExtractor:
  106.     def __init__(self):
  107.         self.parser = LtpParser()
  109.     '''文章分句处理, 切分长句，冒号，分号，感叹号等做切分标识'''
  110.     def split_sents(self, content):
  111.         return [sentence for sentence in re.split(r'[？?！!。；;：:\n\r]', content) if sentence]
  113.     '''利用语义角色标注,直接获取主谓宾三元组,基于A0,A1,A2'''
  114.     def ruler1(self, words, postags, roles_dict, role_index):
  115.         v = words[role_index]
  116.         role_info = roles_dict[role_index]
  117.         if 'A0' in role_info.keys() and 'A1' in role_info.keys():
  118.             s = ''.join([words[word_index] for word_index in range(role_info['A0'][1], role_info['A0'][2]+1) if
  119.                          postags[word_index][0] not in ['w', 'u', 'x'] and words[word_index]])
  120.             o = ''.join([words[word_index] for word_index in range(role_info['A1'][1], role_info['A1'][2]+1) if
  121.                          postags[word_index][0] not in ['w', 'u', 'x'] and words[word_index]])
  122.             if s  and o:
  123.                 return '1', [s, v, o]
  124.         return '4', []
  126.     '''三元组抽取主函数'''
  127.     def ruler2(self, words, postags, child_dict_list, format_parse_list, roles_dict):
  128.         svos = []
  129.         for index in range(len(postags)):
  130.             tmp = 1
  131.             # 先借助语义角色标注的结果，进行三元组抽取
  132.             if index in roles_dict:
  133.                 flag, triple = self.ruler1(words, postags, roles_dict, index)
  134.                 if flag == '1':
  135.                     svos.append(triple)
  136.                     tmp = 0
  137.             if tmp == 1:
  138.                 # 如果语义角色标记为空，则使用依存句法进行抽取
  139.                 # if postags[index] == 'v':
  140.                 if postags[index]:
  141.                 # 抽取以谓词为中心的事实三元组
  142.                     child_dict = child_dict_list[index]
  143.                     # 主谓宾
  144.                     if 'SBV' in child_dict and 'VOB' in child_dict:
  145.                         r = words[index]
  146.                         e1 = self.complete_e(words, postags, child_dict_list, child_dict['SBV'][0])
  147.                         e2 = self.complete_e(words, postags, child_dict_list, child_dict['VOB'][0])
  148.                         svos.append([e1, r, e2])
  150.                     # 定语后置，动宾关系
  151.                     relation = format_parse_list[index][0]
  152.                     head = format_parse_list[index][2]
  153.                     if relation == 'ATT':
  154.                         if 'VOB' in child_dict:
  155.                             e1 = self.complete_e(words, postags, child_dict_list, head - 1)
  156.                             r = words[index]
  157.                             e2 = self.complete_e(words, postags, child_dict_list, child_dict['VOB'][0])
  158.                             temp_string = r + e2
  159.                             if temp_string == e1[:len(temp_string)]:
  160.                                 e1 = e1[len(temp_string):]
  161.                             if temp_string not in e1:
  162.                                 svos.append([e1, r, e2])
  163.                     # 含有介宾关系的主谓动补关系
  164.                     if 'SBV' in child_dict and 'CMP' in child_dict:
  165.                         e1 = self.complete_e(words, postags, child_dict_list, child_dict['SBV'][0])
  166.                         cmp_index = child_dict['CMP'][0]
  167.                         r = words[index] + words[cmp_index]
  168.                         if 'POB' in child_dict_list[cmp_index]:
  169.                             e2 = self.complete_e(words, postags, child_dict_list, child_dict_list[cmp_index]['POB'][0])
  170.                             svos.append([e1, r, e2])
  171.         return svos
  173.     '''对找出的主语或者宾语进行扩展：【定中关系  ATT 红苹果 (红 <– 苹果)】'''
  174.     def complete_e(self, words, postags, child_dict_list, word_index):
  175.         child_dict = child_dict_list[word_index]
  176.         prefix = ''
  177.         if 'ATT' in child_dict:
  178.             for i in range(len(child_dict['ATT'])):
  179.                 prefix += self.complete_e(words, postags, child_dict_list, child_dict['ATT'][i])
  180.         postfix = ''
  181.         if postags[word_index] == 'v':
  182.             if 'VOB' in child_dict:
  183.                 postfix += self.complete_e(words, postags, child_dict_list, child_dict['VOB'][0])
  184.             if 'SBV' in child_dict:
  185.                 prefix = self.complete_e(words, postags, child_dict_list, child_dict['SBV'][0]) + prefix
  187.         return prefix + words[word_index] + postfix
  190.     '''程序主控函数'''
  191.     def triples_main(self, text):
  192.         sentences = self.split_sents(text)
  193.         svos = []
  194.         for index, sentence in enumerate(sentences):
  195.             print("="*50, "第{}句：开始".format(index + 1), "="*50)
  196.             # words: 分词; postags: 词性标注; child_dict_list: 依存句法分析; roles_dict: 语义角色标注
  197.             words, postags, child_dict_list, format_parse_list, roles_dict = self.parser.parser_main(sentence)
  198.             svo = self.ruler2(words, postags, child_dict_list, format_parse_list, roles_dict)
  199.             print("svo = {0}".format(svo))
  200.             print("=" * 50, "第{}句：结束".format(index + 1), "=" * 50)
  201.             svos += svo
  202.         return svos
  204. # 关系抽取
  205. def run_extractor(text):
  206.     extractor = TripleExtractor()
  207.     svos = extractor.triples_main(text)
  208.     return svos
  210. if __name__ == '__main__':
  211.     # 关系抽取
  212.     # text =  '奥巴马与克林顿昨晚在白宫发表了演说'
  213.     text = '我购买了一件玩具，孩子非常喜欢这个玩具，但是质量不太好。希望商家能够保障商品质量，不要再出现类似问题。'
  214.     svos = run_extractor(text)
  215.     print("关系抽取结果：svos = {0}".format(svos))

打印结果：

  1. ================================================== 第1句：开始 ==================================================
  2. -------------------------------------------------- 依存句法分析：开始 --------------------------------------------------
  3. 分词列表：words = ['我', '购买', '了', '一', '件', '玩具', '，', '孩子', '非常', '喜欢', '这个', '玩具', '，', '但是', '质量', '不', '太', '好']
  4. 词性分析：postags = ['r', 'v', 'u', 'm', 'q', 'n', 'wp', 'n', 'd', 'v', 'r', 'n', 'wp', 'c', 'n', 'd', 'd', 'a']
  5. 各个词语所依赖的父节点：rely_ids = [1, -1, 1, 4, 5, 1, 1, 9, 9, 1, 11, 9, 9, 17, 17, 17, 17, 9]
  6. 各个词语所依赖的父节点词语 = ['购买', 'Root', '购买', '件', '玩具', '购买', '购买', '喜欢', '喜欢', '购买', '玩具', '喜欢', '喜欢', '好', '好', '好', '好', '喜欢']
  7. 各个词语与所依赖的父节点的依赖关系 = ['SBV', 'HED', 'RAD', 'ATT', 'ATT', 'VOB', 'WP', 'SBV', 'ADV', 'COO', 'ATT', 'VOB', 'WP', 'ADV', 'SBV', 'ADV', 'ADV', 'COO']
  9. word_index = 0----word = 我
  10. child_dict_list = [{
  11.     }]
  13. word_index = 1----word = 购买
  14. word_index = 1----arc_index = 0----rely_ids[arc_index] = 1----relations[arc_index] = SBV
  15. child_dict = {
  16.     'SBV': [0]}
  17. word_index = 1----arc_index = 2----rely_ids[arc_index] = 1----relations[arc_index] = RAD
  18. child_dict = {
  19.     'SBV': [0], 'RAD': [2]}
  20. word_index = 1----arc_index = 5----rely_ids[arc_index] = 1----relations[arc_index] = VOB
  21. child_dict = {
  22.     'SBV': [0], 'RAD': [2], 'VOB': [5]}
  23. word_index = 1----arc_index = 6----rely_ids[arc_index] = 1----relations[arc_index] = WP
  24. child_dict = {
  25.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6]}
  26. word_index = 1----arc_index = 9----rely_ids[arc_index] = 1----relations[arc_index] = COO
  27. child_dict = {
  28.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}
  29. child_dict_list = [{
  30.     }, {
  31.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}]
  33. word_index = 2----word = 了
  34. child_dict_list = [{
  35.     }, {
  36.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  37.     }]
  39. word_index = 3----word = 一
  40. child_dict_list = [{
  41.     }, {
  42.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  43.     }, {
  44.     }]
  46. word_index = 4----word = 件
  47. word_index = 4----arc_index = 3----rely_ids[arc_index] = 4----relations[arc_index] = ATT
  48. child_dict = {
  49.     'ATT': [3]}
  50. child_dict_list = [{
  51.     }, {
  52.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  53.     }, {
  54.     }, {
  55.     'ATT': [3]}]
  57. word_index = 5----word = 玩具
  58. word_index = 5----arc_index = 4----rely_ids[arc_index] = 5----relations[arc_index] = ATT
  59. child_dict = {
  60.     'ATT': [4]}
  61. child_dict_list = [{
  62.     }, {
  63.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  64.     }, {
  65.     }, {
  66.     'ATT': [3]}, {
  67.     'ATT': [4]}]
  69. word_index = 6----word = ，
  70. child_dict_list = [{
  71.     }, {
  72.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  73.     }, {
  74.     }, {
  75.     'ATT': [3]}, {
  76.     'ATT': [4]}, {
  77.     }]
  79. word_index = 7----word = 孩子
  80. child_dict_list = [{
  81.     }, {
  82.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  83.     }, {
  84.     }, {
  85.     'ATT': [3]}, {
  86.     'ATT': [4]}, {
  87.     }, {
  88.     }]
  90. word_index = 8----word = 非常
  91. child_dict_list = [{
  92.     }, {
  93.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  94.     }, {
  95.     }, {
  96.     'ATT': [3]}, {
  97.     'ATT': [4]}, {
  98.     }, {
  99.     }, {
  100.     }]
  102. word_index = 9----word = 喜欢
  103. word_index = 9----arc_index = 7----rely_ids[arc_index] = 9----relations[arc_index] = SBV
  104. child_dict = {
  105.     'SBV': [7]}
  106. word_index = 9----arc_index = 8----rely_ids[arc_index] = 9----relations[arc_index] = ADV
  107. child_dict = {
  108.     'SBV': [7], 'ADV': [8]}
  109. word_index = 9----arc_index = 11----rely_ids[arc_index] = 9----relations[arc_index] = VOB
  110. child_dict = {
  111.     'SBV': [7], 'ADV': [8], 'VOB': [11]}
  112. word_index = 9----arc_index = 12----rely_ids[arc_index] = 9----relations[arc_index] = WP
  113. child_dict = {
  114.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12]}
  115. word_index = 9----arc_index = 17----rely_ids[arc_index] = 9----relations[arc_index] = COO
  116. child_dict = {
  117.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}
  118. child_dict_list = [{
  119.     }, {
  120.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  121.     }, {
  122.     }, {
  123.     'ATT': [3]}, {
  124.     'ATT': [4]}, {
  125.     }, {
  126.     }, {
  127.     }, {
  128.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}]
  130. word_index = 10----word = 这个
  131. child_dict_list = [{
  132.     }, {
  133.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  134.     }, {
  135.     }, {
  136.     'ATT': [3]}, {
  137.     'ATT': [4]}, {
  138.     }, {
  139.     }, {
  140.     }, {
  141.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  142.     }]
  144. word_index = 11----word = 玩具
  145. word_index = 11----arc_index = 10----rely_ids[arc_index] = 11----relations[arc_index] = ATT
  146. child_dict = {
  147.     'ATT': [10]}
  148. child_dict_list = [{
  149.     }, {
  150.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  151.     }, {
  152.     }, {
  153.     'ATT': [3]}, {
  154.     'ATT': [4]}, {
  155.     }, {
  156.     }, {
  157.     }, {
  158.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  159.     }, {
  160.     'ATT': [10]}]
  162. word_index = 12----word = ，
  163. child_dict_list = [{
  164.     }, {
  165.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  166.     }, {
  167.     }, {
  168.     'ATT': [3]}, {
  169.     'ATT': [4]}, {
  170.     }, {
  171.     }, {
  172.     }, {
  173.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  174.     }, {
  175.     'ATT': [10]}, {
  176.     }]
  178. word_index = 13----word = 但是
  179. child_dict_list = [{
  180.     }, {
  181.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  182.     }, {
  183.     }, {
  184.     'ATT': [3]}, {
  185.     'ATT': [4]}, {
  186.     }, {
  187.     }, {
  188.     }, {
  189.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  190.     }, {
  191.     'ATT': [10]}, {
  192.     }, {
  193.     }]
  195. word_index = 14----word = 质量
  196. child_dict_list = [{
  197.     }, {
  198.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  199.     }, {
  200.     }, {
  201.     'ATT': [3]}, {
  202.     'ATT': [4]}, {
  203.     }, {
  204.     }, {
  205.     }, {
  206.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  207.     }, {
  208.     'ATT': [10]}, {
  209.     }, {
  210.     }, {
  211.     }]
  213. word_index = 15----word = 不
  214. child_dict_list = [{
  215.     }, {
  216.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  217.     }, {
  218.     }, {
  219.     'ATT': [3]}, {
  220.     'ATT': [4]}, {
  221.     }, {
  222.     }, {
  223.     }, {
  224.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  225.     }, {
  226.     'ATT': [10]}, {
  227.     }, {
  228.     }, {
  229.     }, {
  230.     }]
  232. word_index = 16----word = 太
  233. child_dict_list = [{
  234.     }, {
  235.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  236.     }, {
  237.     }, {
  238.     'ATT': [3]}, {
  239.     'ATT': [4]}, {
  240.     }, {
  241.     }, {
  242.     }, {
  243.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  244.     }, {
  245.     'ATT': [10]}, {
  246.     }, {
  247.     }, {
  248.     }, {
  249.     }, {
  250.     }]
  252. word_index = 17----word = 好
  253. word_index = 17----arc_index = 13----rely_ids[arc_index] = 17----relations[arc_index] = ADV
  254. child_dict = {
  255.     'ADV': [13]}
  256. word_index = 17----arc_index = 14----rely_ids[arc_index] = 17----relations[arc_index] = SBV
  257. child_dict = {
  258.     'ADV': [13], 'SBV': [14]}
  259. word_index = 17----arc_index = 15----rely_ids[arc_index] = 17----relations[arc_index] = ADV
  260. child_dict = {
  261.     'ADV': [13, 15], 'SBV': [14]}
  262. word_index = 17----arc_index = 16----rely_ids[arc_index] = 17----relations[arc_index] = ADV
  263. child_dict = {
  264.     'ADV': [13, 15, 16], 'SBV': [14]}
  265. child_dict_list = [{
  266.     }, {
  267.     'SBV': [0], 'RAD': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  268.     }, {
  269.     }, {
  270.     'ATT': [3]}, {
  271.     'ATT': [4]}, {
  272.     }, {
  273.     }, {
  274.     }, {
  275.     'SBV': [7], 'ADV': [8], 'VOB': [11], 'WP': [12], 'COO': [17]}, {
  276.     }, {
  277.     'ATT': [10]}, {
  278.     }, {
  279.     }, {
  280.     }, {
  281.     }, {
  282.     }, {
  283.     'ADV': [13, 15, 16], 'SBV': [14]}]
  284. 整合每个词语的句法依存关系---->format_parse_list =  [['SBV', '我', 0, 'r', '购买', 0, 'r'], ['HED', '购买', 1, 'v', 'Root', -2, 'd'], ['RAD', '了', 2, 'u', '购买', 0, 'r'], ['ATT', '一', 3, 'm', '件', 3, 'm'], ['ATT', '件', 4, 'q', '玩具', 4, 'q'], ['VOB', '玩具', 5, 'n', '购买', 0, 'r'], ['WP', '，', 6, 'wp', '购买', 0, 'r'], ['SBV', '孩子', 7, 'n', '喜欢', 8, 'd'], ['ADV', '非常', 8, 'd', '喜欢', 8, 'd'], ['COO', '喜欢', 9, 'v', '购买', 0, 'r'], ['ATT', '这个', 10, 'r', '玩具', 10, 'r'], ['VOB', '玩具', 11, 'n', '喜欢', 8, 'd'], ['WP', '，', 12, 'wp', '喜欢', 8, 'd'], ['ADV', '但是', 13, 'c', '好', 16, 'd'], ['SBV', '质量', 14, 'n', '好', 16, 'd'], ['ADV', '不', 15, 'd', '好', 16, 'd'], ['ADV', '太', 16, 'd', '好', 16, 'd'], ['COO', '好', 17, 'a', '喜欢', 8, 'd']]
  285. -------------------------------------------------- 依存句法分析：结束 --------------------------------------------------
  286. -------------------------------------------------- 语义角色标注：开始 --------------------------------------------------
  287. 分词----> words= ['我', '购买', '了', '一', '件', '玩具', '，', '孩子', '非常', '喜欢', '这个', '玩具', '，', '但是', '质量', '不', '太', '好']----len(words) = 18
  288. 词性标注----> postags= ['r', 'v', 'u', 'm', 'q', 'n', 'wp', 'n', 'd', 'v', 'r', 'n', 'wp', 'c', 'n', 'd', 'd', 'a']----len(postags) = 18
  289. len(roles) = 2----roles = <pyltp.SementicRoles object at 0x0000026FF8D2E870>
  290. 谓语所在索引：role.index = 1
  291. 谓语所在索引：role.index = 17
  292. 语义角色标注---->roles_dict = {
  293.     1: {
  294.     'A0': ['A0', 0, 0], 'A1': ['A1', 3, 5]}, 17: {
  295.     'DIS': ['DIS', 13, 13], 'A0': ['A0', 14, 14], 'ADV': ['ADV', 16, 16]}}
  296. -------------------------------------------------- 语义角色标注：结束 --------------------------------------------------
  297. svo = [['我', '购买', '一件玩具'], ['孩子', '喜欢', '这个玩具']]
  298. ================================================== 第1句：结束 ==================================================
  299. ================================================== 第2句：开始 ==================================================
  300. -------------------------------------------------- 依存句法分析：开始 --------------------------------------------------
  301. 分词列表：words = ['希望', '商家', '能够', '保障', '商品', '质量', '，', '不要', '再', '出现', '类似', '问题']
  302. 词性分析：postags = ['v', 'n', 'v', 'v', 'n', 'n', 'wp', 'd', 'd', 'v', 'v', 'n']
  303. 各个词语所依赖的父节点：rely_ids = [-1, 3, 3, 0, 5, 3, 3, 9, 9, 3, 11, 9]
  304. 各个词语所依赖的父节点词语 = ['Root', '保障', '保障', '希望', '质量', '保障', '保障', '出现', '出现', '保障', '问题', '出现']
  305. 各个词语与所依赖的父节点的依赖关系 = ['HED', 'SBV', 'ADV', 'VOB', 'ATT', 'VOB', 'WP', 'ADV', 'ADV', 'COO', 'ATT', 'VOB']
  307. word_index = 0----word = 希望
  308. word_index = 0----arc_index = 3----rely_ids[arc_index] = 0----relations[arc_index] = VOB
  309. child_dict = {
  310.     'VOB': [3]}
  311. child_dict_list = [{
  312.     'VOB': [3]}]
  314. word_index = 1----word = 商家
  315. child_dict_list = [{
  316.     'VOB': [3]}, {
  317.     }]
  319. word_index = 2----word = 能够
  320. child_dict_list = [{
  321.     'VOB': [3]}, {
  322.     }, {
  323.     }]
  325. word_index = 3----word = 保障
  326. word_index = 3----arc_index = 1----rely_ids[arc_index] = 3----relations[arc_index] = SBV
  327. child_dict = {
  328.     'SBV': [1]}
  329. word_index = 3----arc_index = 2----rely_ids[arc_index] = 3----relations[arc_index] = ADV
  330. child_dict = {
  331.     'SBV': [1], 'ADV': [2]}
  332. word_index = 3----arc_index = 5----rely_ids[arc_index] = 3----relations[arc_index] = VOB
  333. child_dict = {
  334.     'SBV': [1], 'ADV': [2], 'VOB': [5]}
  335. word_index = 3----arc_index = 6----rely_ids[arc_index] = 3----relations[arc_index] = WP
  336. child_dict = {
  337.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6]}
  338. word_index = 3----arc_index = 9----rely_ids[arc_index] = 3----relations[arc_index] = COO
  339. child_dict = {
  340.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}
  341. child_dict_list = [{
  342.     'VOB': [3]}, {
  343.     }, {
  344.     }, {
  345.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}]
  347. word_index = 4----word = 商品
  348. child_dict_list = [{
  349.     'VOB': [3]}, {
  350.     }, {
  351.     }, {
  352.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  353.     }]
  355. word_index = 5----word = 质量
  356. word_index = 5----arc_index = 4----rely_ids[arc_index] = 5----relations[arc_index] = ATT
  357. child_dict = {
  358.     'ATT': [4]}
  359. child_dict_list = [{
  360.     'VOB': [3]}, {
  361.     }, {
  362.     }, {
  363.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  364.     }, {
  365.     'ATT': [4]}]
  367. word_index = 6----word = ，
  368. child_dict_list = [{
  369.     'VOB': [3]}, {
  370.     }, {
  371.     }, {
  372.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  373.     }, {
  374.     'ATT': [4]}, {
  375.     }]
  377. word_index = 7----word = 不要
  378. child_dict_list = [{
  379.     'VOB': [3]}, {
  380.     }, {
  381.     }, {
  382.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  383.     }, {
  384.     'ATT': [4]}, {
  385.     }, {
  386.     }]
  388. word_index = 8----word = 再
  389. child_dict_list = [{
  390.     'VOB': [3]}, {
  391.     }, {
  392.     }, {
  393.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  394.     }, {
  395.     'ATT': [4]}, {
  396.     }, {
  397.     }, {
  398.     }]
  400. word_index = 9----word = 出现
  401. word_index = 9----arc_index = 7----rely_ids[arc_index] = 9----relations[arc_index] = ADV
  402. child_dict = {
  403.     'ADV': [7]}
  404. word_index = 9----arc_index = 8----rely_ids[arc_index] = 9----relations[arc_index] = ADV
  405. child_dict = {
  406.     'ADV': [7, 8]}
  407. word_index = 9----arc_index = 11----rely_ids[arc_index] = 9----relations[arc_index] = VOB
  408. child_dict = {
  409.     'ADV': [7, 8], 'VOB': [11]}
  410. child_dict_list = [{
  411.     'VOB': [3]}, {
  412.     }, {
  413.     }, {
  414.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  415.     }, {
  416.     'ATT': [4]}, {
  417.     }, {
  418.     }, {
  419.     }, {
  420.     'ADV': [7, 8], 'VOB': [11]}]
  422. word_index = 10----word = 类似
  423. child_dict_list = [{
  424.     'VOB': [3]}, {
  425.     }, {
  426.     }, {
  427.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  428.     }, {
  429.     'ATT': [4]}, {
  430.     }, {
  431.     }, {
  432.     }, {
  433.     'ADV': [7, 8], 'VOB': [11]}, {
  434.     }]
  436. word_index = 11----word = 问题
  437. word_index = 11----arc_index = 10----rely_ids[arc_index] = 11----relations[arc_index] = ATT
  438. child_dict = {
  439.     'ATT': [10]}
  440. child_dict_list = [{
  441.     'VOB': [3]}, {
  442.     }, {
  443.     }, {
  444.     'SBV': [1], 'ADV': [2], 'VOB': [5], 'WP': [6], 'COO': [9]}, {
  445.     }, {
  446.     'ATT': [4]}, {
  447.     }, {
  448.     }, {
  449.     }, {
  450.     'ADV': [7, 8], 'VOB': [11]}, {
  451.     }, {
  452.     'ATT': [10]}]
  453. 整合每个词语的句法依存关系---->format_parse_list =  [['HED', '希望', 0, 'v', 'Root', -2, 'v'], ['SBV', '商家', 1, 'n', '保障', 2, 'v'], ['ADV', '能够', 2, 'v', '保障', 2, 'v'], ['VOB', '保障', 3, 'v', '希望', -1, 'n'], ['ATT', '商品', 4, 'n', '质量', 4, 'n'], ['VOB', '质量', 5, 'n', '保障', 2, 'v'], ['WP', '，', 6, 'wp', '保障', 2, 'v'], ['ADV', '不要', 7, 'd', '出现', 8, 'd'], ['ADV', '再', 8, 'd', '出现', 8, 'd'], ['COO', '出现', 9, 'v', '保障', 2, 'v'], ['ATT', '类似', 10, 'v', '问题', 10, 'v'], ['VOB', '问题', 11, 'n', '出现', 8, 'd']]
  454. -------------------------------------------------- 依存句法分析：结束 --------------------------------------------------
  455. -------------------------------------------------- 语义角色标注：开始 --------------------------------------------------
  456. 分词----> words= ['希望', '商家', '能够', '保障', '商品', '质量', '，', '不要', '再', '出现', '类似', '问题']----len(words) = 12
  457. 词性标注----> postags= ['v', 'n', 'v', 'v', 'n', 'n', 'wp', 'd', 'd', 'v', 'v', 'n']----len(postags) = 12
  458. len(roles) = 4----roles = <pyltp.SementicRoles object at 0x0000026FF8D2E870>
  459. 谓语所在索引：role.index = 0
  460. 谓语所在索引：role.index = 3
  461. 谓语所在索引：role.index = 7
  462. 谓语所在索引：role.index = 9
  463. 语义角色标注---->roles_dict = {
  464.     0: {
  465.     'A1': ['A1', 1, 11]}, 3: {
  466.     'A0': ['A0', 1, 1], 'A1': ['A1', 4, 5]}, 7: {
  467.     'A0': ['A0', 1, 1]}, 9: {
  468.     'ADV': ['ADV', 8, 8], 'A1': ['A1', 10, 11]}}
  469. -------------------------------------------------- 语义角色标注：结束 --------------------------------------------------
  470. svo = [['商家', '保障', '商品质量']]
  471. ================================================== 第2句：结束 ==================================================
  472. 关系抽取结果：svos = [['我', '购买', '一件玩具'], ['孩子', '喜欢', '这个玩具'], ['商家', '保障', '商品质量']]
  474. Process finished with exit code 0

四、构建知识图谱

通过上一步骤的关系抽取的三元组结果【A0（触发者）、谓语词、A1（受事者）】就可以创建知识图谱的实体与关系。

发表评论

表情：
评论列表 （有 0 条评论，65人围观）

还没有评论，来说两句吧...

相关阅读