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

golang知识图谱NLP实战第二节——解析依存句法分析结果_句法依存知识图谱

作者：繁依Fanyi0 | 2024-03-31 00:03:09

赞

踩

句法依存知识图谱

 golang知识图谱NLP实战第一节——整体思路

golang知识图谱NLP实战第二节——解析依存句法分析结果

golang知识图谱NLP实战第三节——关系抽取

1 参考资料

基于依存句法分析的开放式中文实体关系抽取https://blog.csdn.net/heuguangxu/article/details/80088489

基于神经网络的高性能依存句法分析器http://www.hankcs.com/nlp/parsing/neural-network-based-dependency-parser.html

基于依存关系的空间关系抽取算法https://blog.csdn.net/sinat_28901239/article/details/52184531

语言云API使用文档https://www.ltp-cloud.com/document/

https://api.ltp-cloud.com/analysis/?api_key=U1H0S1Z1CkcUtrLouJvyHVNSOWkY9ycmAVahcduW&text=%E6%88%BF%E9%A1%B6%E4%B8%8A%E8%90%BD%E7%9D%80%E4%B8%80%E5%8F%AA%E5%B0%8F%E9%B8%9F&pattern=all&format=xml

2 思路过程

可以用hanlp做句子的依存句法分析，得到字段如下：问题，怎样得到json数据？怎样让hanlp提供服务？

  1. 1 房顶  房顶  n n _ 2 定中关系  _ _
  2. 2 上 上 nd  f _ 3 状中结构  _ _
  3. 3 站 站 v v _ 0 核心关系  _ _
  4. 4 着 着 u u _ 3 右附加关系 _ _
  5. 5 一 一 m m _ 6 定中关系  _ _
  6. 6 只 只 q q _ 7 定中关系  _ _
  7. 7 小鸟  小鸟  n n _ 3 动宾关系  _ _

也可以用语言云API，得到json数据如下

  1. [
  2.  [
  3.   [
  4.    {
  5.     "id": 0, 
  6.     "cont": "房顶", 
  7.     "pos": "n", 
  8.     "ne": "O", 
  9.     "parent": 1, 
  10.     "relate": "ATT", 
  11.     "semparent": 2, 
  12.     "semrelate": "Loc", 
  13.     "arg": [], 
  14.     "sem": [
  15.      {
  16.       "id": 0, 
  17.       "parent": 2, 
  18.       "relate": "Loc"
  19.      }
  20.     ]
  21.    }, 
  22.    {
  23.     "id": 1, 
  24.     "cont": "上", 
  25.     "pos": "nd", 
  26.     "ne": "O", 
  27.     "parent": 2, 
  28.     "relate": "ADV", 
  29.     "semparent": 0, 
  30.     "semrelate": "mRang", 
  31.     "arg": [], 
  32.     "sem": [
  33.      {
  34.       "id": 0, 
  35.       "parent": 0, 
  36.       "relate": "mRang"
  37.      }
  38.     ]
  39.    }, 
  40.    {
  41.     "id": 2, 
  42.     "cont": "落", 
  43.     "pos": "v", 
  44.     "ne": "O", 
  45.     "parent": -1, 
  46.     "relate": "HED", 
  47.     "semparent": -1, 
  48.     "semrelate": "Root", 
  49.     "arg": [
  50.      {
  51.       "id": 0, 
  52.       "type": "LOC", 
  53.       "beg": 0, 
  54.       "end": 1
  55.      }, 
  56.      {
  57.       "id": 1, 
  58.       "type": "A1", 
  59.       "beg": 4, 
  60.       "end": 6
  61.      }
  62.     ], 
  63.     "sem": [
  64.      {
  65.       "id": 0, 
  66.       "parent": -1, 
  67.       "relate": "Root"
  68.      }
  69.     ]
  70.    }, 
  71.    {
  72.     "id": 3, 
  73.     "cont": "着", 
  74.     "pos": "u", 
  75.     "ne": "O", 
  76.     "parent": 2, 
  77.     "relate": "RAD", 
  78.     "semparent": 2, 
  79.     "semrelate": "mTime", 
  80.     "arg": [], 
  81.     "sem": [
  82.      {
  83.       "id": 0, 
  84.       "parent": 2, 
  85.       "relate": "mTime"
  86.      }
  87.     ]
  88.    }, 
  89.    {
  90.     "id": 4, 
  91.     "cont": "一", 
  92.     "pos": "m", 
  93.     "ne": "O", 
  94.     "parent": 5, 
  95.     "relate": "ATT", 
  96.     "semparent": 5, 
  97.     "semrelate": "Quan", 
  98.     "arg": [], 
  99.     "sem": [
  100.      {
  101.       "id": 0, 
  102.       "parent": 5, 
  103.       "relate": "Quan"
  104.      }
  105.     ]
  106.    }, 
  107.    {
  108.     "id": 5, 
  109.     "cont": "只", 
  110.     "pos": "q", 
  111.     "ne": "O", 
  112.     "parent": 6, 
  113.     "relate": "ATT", 
  114.     "semparent": 6, 
  115.     "semrelate": "Qp", 
  116.     "arg": [], 
  117.     "sem": [
  118.      {
  119.       "id": 0, 
  120.       "parent": 6, 
  121.       "relate": "Qp"
  122.      }
  123.     ]
  124.    }, 
  125.    {
  126.     "id": 6, 
  127.     "cont": "小鸟", 
  128.     "pos": "n", 
  129.     "ne": "O", 
  130.     "parent": 2, 
  131.     "relate": "VOB", 
  132.     "semparent": 2, 
  133.     "semrelate": "Exp", 
  134.     "arg": [], 
  135.     "sem": [
  136.      {
  137.       "id": 0, 
  138.       "parent": 2, 
  139.       "relate": "Exp"
  140.      }
  141.     ]
  142.    }
  143.   ]
  144.  ]
  145. ]

那么有了以上数据，从go语言角度，如何实现关系抽取呢？按照上述的参考文章，先将数据转为struct，然后进行判断逻辑关系，无论是主谓关系，定中关系……还是空间方位……通过代码找出三元体吧。下一节贴出。以下是先实现了2种数据转为struct。 

  1. package main
  2.  
  3. import (
  4. 	//	"bytes"
  5. 	//	"crypto/aes"
  6. 	//	"crypto/cipher"
  7. 	//	"crypto/rand"
  8. 	"encoding/json"
  9. 	"fmt"
  10. 	//	"io"
  11. 	//	"io/ioutil"
  12. 	"log"
  13. 	//	"os"
  14. 	//	"github.com/bitly/go-simplejson" // for json get
  15. 	"strings"
  16. )
  17.  
  18. type Hanlp struct {
  19. 	ID      string `json:"id"`
  20. 	FORM    string `json:"form"`
  21. 	LEMMA   string `json:"lemma"`
  22. 	CPOSTAG string `json:"cpostag"`
  23. 	POSTAG  string `json:"postag"`
  24. 	FEATS   string `json:"feats"`
  25. 	HEAD    string `json:"head"`
  26. 	DEPREL  string `json:"deprel"`
  27. }
  28.  
  29. type Ltp2 struct {
  30. 	Ltptwo []Ltp1
  31. }
  32.  
  33. type Ltp1 struct { //这个办法不行，保留！
  34. 	Ltpone []Ltp
  35. }
  36.  
  37. type Ltp struct {
  38. 	Id        int64  `json:"id"`
  39. 	Cont      string `json:"cont"`
  40. 	Pos       string `json:"pos"`
  41. 	Ne        string `json:"ne"`
  42. 	Parent    int64  `json:"parent"`
  43. 	Relate    string `json:"relate"`
  44. 	Semparent int64  `json:"semparent"`
  45. 	Semrelate string `json:"semrelate"`
  46. 	Arg       []Arg1 `json:"arg"`
  47. 	Sem       []Sem1 `json:"sem"`
  48. }
  49.  
  50. type Sem1 struct {
  51. 	Id     int64  `json:"id"`
  52. 	Parent int64  `json:"parent"`
  53. 	Relate string `json:"relate"`
  54. }
  55.  
  56. type Arg1 struct {
  57. 	Id   int64  `json:"id"`
  58. 	Type string `json:"type"`
  59. 	Beg  int64  `json:"beg"`
  60. 	End  int64  `json:"end"`
  61. }
  62.  
  63. func main() {
  64. 	jsonHanlpStr := `1 房顶  房顶  n n _ 2 定中关系  _ _
  65. 2 上 上 nd  f _ 3 状中结构  _ _
  66. 3 站 站 v v _ 0 核心关系  _ _
  67. 4 着 着 u u _ 3 右附加关系 _ _
  68. 5 一 一 m m _ 6 定中关系  _ _
  69. 6 只 只 q q _ 7 定中关系  _ _
  70. 7 小鸟  小鸟  n n _ 3 动宾关系  _ _`
  71. 	//	var hanlp []Hanlp
  72. 	hanlp := make([]Hanlp, 0) //这里不能加*号
  73. 	aa := make([]Hanlp, 1)
  74. 	array := strings.Split(jsonHanlpStr, "\n")
  75. 	for _, v := range array {
  76. 		array1 := strings.Split(v, " ")
  77. 		//		for _, w := range array1 {
  78. 		aa[0].ID = array1[0]
  79. 		aa[0].FORM = array1[1]
  80. 		aa[0].LEMMA = array1[3]
  81. 		aa[0].CPOSTAG = array1[5]
  82. 		aa[0].POSTAG = array1[6]
  83. 		aa[0].FEATS = array1[7]
  84. 		aa[0].HEAD = array1[8]
  85. 		aa[0].DEPREL = array1[9]
  86. 		//		}
  87. 		hanlp = append(hanlp, aa...)
  88. 	}
  89. 	fmt.Println(hanlp)
  90. 	//	jsonLtpStr := `[[[{"id": 0,"cont": "房顶","pos": "n","ne": "O","parent": 1,
  91. 	//"relate": "ATT","semparent": 2,"semrelate": "Loc","arg": [],"sem": [{"id": 0,
  92. 	//"parent": 2,"relate": "Loc"}]}]]]`
  93.  
  94. 	jsonLtpStr := `[
  95.  [
  96.   [
  97.    {
  98.     "id": 0, 
  99.     "cont": "房顶", 
  100.     "pos": "n", 
  101.     "ne": "O", 
  102.     "parent": 1, 
  103.     "relate": "ATT", 
  104.     "semparent": 2, 
  105.     "semrelate": "Loc", 
  106.     "arg": [], 
  107.     "sem": [
  108.      {
  109.       "id": 0, 
  110.       "parent": 2, 
  111.       "relate": "Loc"
  112.      }
  113.     ]
  114.    }, 
  115.    {
  116.     "id": 1, 
  117.     "cont": "上", 
  118.     "pos": "nd", 
  119.     "ne": "O", 
  120.     "parent": 2, 
  121.     "relate": "ADV", 
  122.     "semparent": 0, 
  123.     "semrelate": "mRang", 
  124.     "arg": [], 
  125.     "sem": [
  126.      {
  127.       "id": 0, 
  128.       "parent": 0, 
  129.       "relate": "mRang"
  130.      }
  131.     ]
  132.    }, 
  133.    {
  134.     "id": 2, 
  135.     "cont": "落", 
  136.     "pos": "v", 
  137.     "ne": "O", 
  138.     "parent": -1, 
  139.     "relate": "HED", 
  140.     "semparent": -1, 
  141.     "semrelate": "Root", 
  142.     "arg": [
  143.      {
  144.       "id": 0, 
  145.       "type": "LOC", 
  146.       "beg": 0, 
  147.       "end": 1
  148.      }, 
  149.      {
  150.       "id": 1, 
  151.       "type": "A1", 
  152.       "beg": 4, 
  153.       "end": 6
  154.      }
  155.     ], 
  156.     "sem": [
  157.      {
  158.       "id": 0, 
  159.       "parent": -1, 
  160.       "relate": "Root"
  161.      }
  162.     ]
  163.    }, 
  164.    {
  165.     "id": 3, 
  166.     "cont": "着", 
  167.     "pos": "u", 
  168.     "ne": "O", 
  169.     "parent": 2, 
  170.     "relate": "RAD", 
  171.     "semparent": 2, 
  172.     "semrelate": "mTime", 
  173.     "arg": [], 
  174.     "sem": [
  175.      {
  176.       "id": 0, 
  177.       "parent": 2, 
  178.       "relate": "mTime"
  179.      }
  180.     ]
  181.    }, 
  182.    {
  183.     "id": 4, 
  184.     "cont": "一", 
  185.     "pos": "m", 
  186.     "ne": "O", 
  187.     "parent": 5, 
  188.     "relate": "ATT", 
  189.     "semparent": 5, 
  190.     "semrelate": "Quan", 
  191.     "arg": [], 
  192.     "sem": [
  193.      {
  194.       "id": 0, 
  195.       "parent": 5, 
  196.       "relate": "Quan"
  197.      }
  198.     ]
  199.    }, 
  200.    {
  201.     "id": 5, 
  202.     "cont": "只", 
  203.     "pos": "q", 
  204.     "ne": "O", 
  205.     "parent": 6, 
  206.     "relate": "ATT", 
  207.     "semparent": 6, 
  208.     "semrelate": "Qp", 
  209.     "arg": [], 
  210.     "sem": [
  211.      {
  212.       "id": 0, 
  213.       "parent": 6, 
  214.       "relate": "Qp"
  215.      }
  216.     ]
  217.    }, 
  218.    {
  219.     "id": 6, 
  220.     "cont": "小鸟", 
  221.     "pos": "n", 
  222.     "ne": "O", 
  223.     "parent": 2, 
  224.     "relate": "VOB", 
  225.     "semparent": 2, 
  226.     "semrelate": "Exp", 
  227.     "arg": [], 
  228.     "sem": [
  229.      {
  230.       "id": 0, 
  231.       "parent": 2, 
  232.       "relate": "Exp"
  233.      }
  234.     ]
  235.    }
  236.   ]
  237.  ]
  238. ]`
  239. 	//json字符串解析到结构体，以便进行追加
  240. 	var ltp [][][]Ltp
  241. 	err := json.Unmarshal([]byte(jsonLtpStr), &ltp)
  242. 	if err != nil {
  243. 		//		beego.Error(err)
  244. 		log.Fatal(err)
  245. 	}
  246. 	fmt.Println(ltp)
  247. 	fmt.Println(ltp[0][0][0].Parent)
  248. 	//json str 转struct
  249. 	//	var config ConfigStruct
  250. 	//	if err := json.Unmarshal([]byte(jsonStr), &config); err == nil {
  251. 	//		fmt.Println("================json str 转struct==")
  252. 	//		fmt.Println(config)
  253. 	//		fmt.Println(config.Host)
  254. 	//	}
  255. }

打印结果

  1. D:/Go/bin/go.exe build -i [D:/gowork/src/test_go]
  2. 成功: 进程退出代码 0.
  3. D:/gowork/src/test_go/test_go.exe  [D:/gowork/src/test_go]
  4. table `user` already exists, skip
  5. [{1 房顶 房顶 n n _ 2 定中关系} {2 上 nd f _ 3 状中结构 } {3 站 v _ 0 核心关系  _} {4 着 u _ 3 右附加关系 _ _} {5 一 m _ 6 定中关系  _} {6 只 q _ 7 定中关系  _} {7 小鸟 小鸟 n n _ 3 动宾关系}]
  6. [[[{0 房顶 n O 1 ATT 2 Loc [] [{0 2 Loc}]} {1 上 nd O 2 ADV 0 mRang [] [{0 0 mRang}]} {2 落 v O -1 HED -1 Root [{0 LOC 0 1} {1 A1 4 6}] [{0 -1 Root}]} {3 着 u O 2 RAD 2 mTime [] [{0 2 mTime}]} {4 一 m O 5 ATT 5 Quan [] [{0 5 Quan}]} {5 只 q O 6 ATT 6 Qp [] [{0 6 Qp}]} {6 小鸟 n O 2 VOB 2 Exp [] [{0 2 Exp}]}]]]
  7. 1
  8. 成功: 进程退出代码 0.

 

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

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

  

闽ICP备14008679号