0


SpringBoot 整合 Neo4j

知识图谱技术

三要素

在知识图谱中,通过三元组 <实体 × 关系 × 属性> 集合的形式来描述事物之间的关系:

  • 实体:又叫作本体,指客观存在并可相互区别的事物,可以是具体的人、事、物,也可以是抽象的概念或联系,实体是知识图谱中最基本的元素
  • 关系:在知识图谱中,边表示知识图谱中的关系,用来表示不同实体间的某种联系
  • 属性:知识图谱中的实体和关系都可以有各自的属性

这里所说的实体和普通意义上的实体略有不同,借用 NLP 中本体的概念来理解它会比较好:

本体定义了组成主题领域的词汇表的基本术语及其关系,以及结合这些术语和关系来定义词汇表外延的规则

例如我们要描述大学这一领域时,对它来说教工学生课程就是相对比较重要的概念,并且教工和学生之间也存在一定的关联关系,此外对象之间还存在一定的约束关系,例如一个系的教职员工数量不能少于 10 人。

在了解了上面的三元组后,我们可以基于它构建下面这样的一个关系:

可以看到,女王和王储通过母子关系关联在一起,并且每个人拥有自己的属性。

当知识图谱中的节点逐渐增多后,它的表现形式就会类似于化学分子式的结构,一个知识图谱往往存在多种类型的实体与关系。

知识图谱将非线性世界中的知识信息进行加工,做到这样的结构化、可视化,从而辅助人类进行推理、预判、归类。

到这里,可以简单概括一下知识图谱的基本特征:

  • 知识结构网络化
  • 网络结构复杂
  • 网络由三元组构成
  • 数据主要由知识库承载

场景

搜索

前面提到过,以前的搜索引擎是从海量的关键词中找出与查询匹配度最高的内容,按照查询结果把排序分值最高的一些结果返回给用户。在整个过程中,搜索引擎可能并不需要知道用户输入的是什么,因为系统不具备推理能力,在精准搜索方面也略显不足。而基于知识图谱的搜索引擎,除了能够直接回答用户的问题外,还具有一定的语义推理能力,大大提高了搜索的精确度。

推荐

在传统的推荐系统中,存在两个典型问题:

  • 数据稀疏问题:在实际应用场景中,用户和物品的交互信息往往是非常稀疏的,预测会产生过拟合风险
  • 冷启动问题:对于新加入的用户或者物品,由于系统没有其历史交互信息,因此无法进行准确地建模和推荐

例如,在一个电影类网站中可能包含了上万部电影,然而一个用户打过分的电影可能平均只有几十部。使用如此少量的已观测数据来预测大量的未知信息,会极大地增加算法的过拟合风险。

因此在推荐算法中会额外引入一些辅助信息作为输入,这些辅助信息可以丰富对用户和物品的描述,从而有效地弥补交互信息的稀疏或缺失。在各种辅助信息中,知识图谱作为一种新兴类型的辅助信息,这几年的相关研究比较多。

下面就是一个基于知识图谱的推荐例子:

在将知识图谱引入推荐系统后,具有以下优势:

  • 精确性:知识图谱为物品引入了更多的语义关系,可以深层次地发现用户兴趣
  • 多样性:知识图谱提供了实体之间不同的关系连接种类,有利于推荐结果的发散,避免推荐结果局限于单一类型
  • 可解释性:知识图谱可以连接用户的历史记录和推荐结果,从而提高用户对推荐结果的满意度和接受度,增强用户对推荐系统的信

此外,知识图谱技术还在问答与对话系统、语言理解、决策分析等多个领域被广泛应用,它被挂载在这些系统之后,充当背景知识库的角色。总的来说,在这些场景下的应用,可以概括整个 AI 的发展趋势,就是从感知认知的一个过程。

关系抽取

回顾一下我们前面提到过的知识图谱三要素,分别是实体、关系和属性。关系抽取我们同样可以用一个三元组表示的

RDF graph

这样的一个(S,P,O)三元组,就可以将一份知识分解为主语、谓语、宾语。这样的 SPO 结构,在配合知识图谱进行存储时可以被用来当做存储单元。

流程与算法

在知识图谱的搭建过程中,仍然面临着各类算法难点,主要难点可归结为生产流程中的算法难点和算法性能上的难点。前者体现为知识获取受数据集限制、知识融合干扰因素较多、知识计算的数据集与算力不足等问题。

而后者体现为算法泛化能力不足、鲁棒性不足、缺乏统一测评指标等问题。算法上的难点有赖于供需双方、学术界、政府持续攻坚,而非一方努力即可收获成功。

Neo4j 实战

我们上面介绍了关于知识图谱的一些基本理论知识,俗话说的好,光说不练假把式。

下面将通过下面几个主要模块,构建自然界中实体间的联系,实现知识图谱描述:

  • 图数据库 Neo4j 安装
  • 简单 CQL 入门
  • Spring Boot 整合 Neo4j
  • 文本 SPO 抽取
  • 动态构建知识图谱

Neo4j 安装

知识图谱的底层依赖于关键的图数据库,在这里我们选择 Neo4j,它是一款高性能的 nosql 图形数据库,能够将结构化的数据存储在而不是中。

首先进行安装,打开官网下载 Neo4j 的安装包,下载免费的 community 社区版就可以,地址放在下面:

https://Neo4j.com/download/other-releases/

需要注意的是,Neo4j 4.x 以上的版本都需要依赖 jdk11 环境,所以如果运行环境是 jdk8 的话,那么还是老老实实下载 3.x 版本就行,下载解压完成后,在

bin

目录下通过命令启动:

Neo4j console

启动后在浏览器访问安装服务器的 7474 端口,就可以打开 Neo4j 的控制台页面:

通过左侧的导航栏,我们依次可以查看存储的数据、一些基础查询的示例以及一些帮助说明。

而顶部带有

$

符号的输入框,可以用来输入 Neo4j 特有的 CQL 查询语句并执行,具体的语法我们放在下面介绍。

简单 CQL 入门

就像我们平常使用关系型数据库中的 SQL 语句一样,Neo4j 中可以使用 Cypher 查询语言(CQL)进行图形数据库的查询,我们简单来看一下增删改查的用法。

添加节点

在 CQL 中,可以通过

CREATE

命令去创建一个节点,创建不含有属性节点的语法如下:

CREATE (<node-name>:<label-name>)

CREATE

语句中,包含两个基础元素,节点名称

node-name

和标签名称

lable-name

。标签名称相当于关系型数据库中的表名,而节点名称则代指这一条数据。

以下面的

CREATE

语句为例,就相当于在

Person

这张表中创建一条没有属性的空数据。

CREATE (索尔:Person)

而创建包含属性的节点时,可以在标签名称后面追加一个描绘属性的

json

字符串:

CREATE (
   <node-name>:<label-name>
   {
      <key1>:<value1>,
      …
      <keyN>:<valueN>
   }
)

用下面的语句创建一个包含属性的节点:

CREATE (洛基:Person {name:"洛基",title:"诡计之神"})

查询节点

在创建完节点后,我们就可以使用

MATCH

匹配命令查询已存在的节点及属性的数据,命令的格式如下:

MATCH (<node-name>:<label-name>)

通常,

MATCH

命令在后面配合

RETURN

DELETE

等命令使用,执行具体的返回或删除等操作。

执行下面的命令:

MATCH (p:Person) RETURN p

查看可视化的显示结果:

可以看到上面添加的两个节点,分别是不包含属性的空节点和包含属性的节点,并且所有节点会有一个默认生成的

id

作为唯一标识。

删除节点

接下来,我们删除之前创建的不包含属性的无用节点,上面提到过,需要使用

MATCH

配合

DELETE

进行删除。

MATCH (p:Person) WHERE id(p)=100
DELETE p

在这条删除语句中,额外使用了

WHERE

过滤条件,它与 SQL 中的

WHERE

非常相似,命令中通过节点的

id

进行了过滤。

删除完成后,再次执行查询操作,可以看到只保留了

洛基

这一个节点:

添加关联

在 Neo4j 图数据库中,遵循属性图模型来存储和管理数据,也就是说我们可以维护节点之间的关系。

在上面,我们创建过一个节点,所以还需要再创建一个节点作为关系的两端:

CREATE (p:Person {name:"索尔",title:"雷神"})

创建关系的基本语法如下:

CREATE (<node-name1>:<label-name1>)
- [<relation-name>:<relation-label-name>]
-> (<node-name2>:<label-name2>)

当然,也可以利用已经存在的节点创建关系,下面我们借助

MATCH

先进行查询,再将结果进行关联,创建两个节点之间的关联关系:

MATCH (m:Person),(n:Person)
WHERE m.name='索尔' and n.name='洛基'
CREATE (m)-[r:BROTHER {relation:"无血缘兄弟"}]->(n)
RETURN r

添加完成后,可以通过关系查询符合条件的节点及关系:

MATCH (m:Person)-[re:BROTHER]->(n:Person)
RETURN m,re,n

可以看到两者之间已经添加了关联:

需要注意的是,如果节点被添加了关联关系后,单纯删除节点的话会报错,:

Neo.ClientError.Schema.ConstraintValidationFailed
Cannot delete node<85>, because it still has relationships. To delete this node, you must first delete its relationships.

这时,需要在删除节点时同时删除关联关系:

MATCH (m:Person)-[r:BROTHER]->(n:Person)
DELETE m,r

执行上面的语句,就会在删除节点的同时,删除它所包含的关联关系了。

那么,简单的 cql 语句入门到此为止,它已经基本能够满足我们的简单业务场景了,下面我们开始在 springboot 中整合 Neo4j。

SpringBoot 整合 Neo4j

创建一个 springboot 项目,这里使用的是

2.3.4

版本,引入 Neo4j 的依赖坐标:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-Neo4j</artifactId>
</dependency>

application.yml

中配置 Neo4j 连接信息:

spring:
  data:
    Neo4j:
      uri: bolt://127.0.0.1:7687
      username: Neo4j
      password: 123456

大家如果对

jpa

的应用非常熟练的话,那么接下来的过程可以说是轻车熟路,因为它们基本上是一个模式,同样是构建 model 层、repository 层,然后在此基础上操作自定义或模板方法就可以了。

节点实体

我们可以使用基于注解的实体映射来描述图中的节点,通过在实体类上添加

@NodeEntity

表明它是图中的一个节点实体,在属性上添加

@Property

代表它是节点中的具体属性。

@Data
@NodeEntity(label = "Person")
public class Node {
    @Id
    @GeneratedValue
    private Long id;

    @Property(name = "name")
    private String name;

    @Property(name = "title")
    private String title;
}

这样一个实体类,就代表它创建的实例节点的

<label-name>

Person

,并且每个节点拥有

name

title

两个属性。

Repository 持久层

对上面的实体构建持久层接口,继承

Neo4jRepository

接口,并在接口上添加

@Repository

注解即可。

@Repository
public interface NodeRepository extends Neo4jRepository<Node,Long> {
    @Query("MATCH p=(n:Person) RETURN p")
    List<Node> selectAll();

    @Query("MATCH(p:Person{name:{name}}) return p")
    Node findByName(String name);
}

在接口中添加了个两个方法,供后面测试使用,

selectAll()

用于返回全部数据,

findByName()

用于根据

name

查询特定的节点。

接下来,在 service 层中调用 repository 层的模板方法:

@Service
@AllArgsConstructor
public class NodeServiceImpl implements NodeService {
    private final NodeRepository nodeRepository;

    @Override
    public Node save(Node node) {
        Node save = nodeRepository.save(node);
        return save;
    }
}

前端调用

save()

接口,添加一个节点后,再到控制台用查询语句进行查询,可以看到新的节点已经通过接口方式被添加到了图中:

在 service 中再添加一个方法,用于查询全部节点,直接调用我们在

NodeRepository

中定义的

selectAll()

方法:

@Override
public List<Node> getAll() {
    List<Node> nodes = nodeRepository.selectAll();
    nodes.forEach(System.out::println);
    return nodes;
}

在控制台打印了查询结果:

图片

对节点的操作我们就介绍到这里,接下来开始构建节点间的关联关系。

关联关系

在 Neo4j 中,关联关系其实也可以看做一种特殊的实体,所以可以用实体类来对其进行描述。与节点不同,需要在类上添加

@RelationshipEntity

注解,并通过

@StartNode

@EndNode

指定关联关系的开始和结束节点。

@Data
@RelationshipEntity(type = "Relation")
public class Relation {
    @Id
    @GeneratedValue
    private Long id;

    @StartNode
    private Node startNode;

    @EndNode
    private Node endNode;

    @Property
    private String relation;
}

同样,接下来也为它创建一个持久层的接口:

@Repository
public interface RelationRepository extends Neo4jRepository<Relation,Long> {
    @Query("MATCH p=(n:Person)-[r:Relation]->(m:Person) " +
            "WHERE id(n)={startNode} and id(m)={endNode} and r.relation={relation}" +
            "RETURN p")
    List<Relation> findRelation(@Param("startNode") Node startNode,
                                @Param("endNode") Node endNode,
                                @Param("relation") String relation);
}

在接口中自定义了一个根据起始节点、结束节点以及关联内容查询关联关系的方法,我们会在后面用到。

创建关联

在 service 层中,创建提供一个根据节点名称构建关联关系的方法:

@Override
public void bind(String name1, String name2, String relationName) {
    Node start = nodeRepository.findByName(name1);
    Node end = nodeRepository.findByName(name2);

    Relation relation =new Relation();
    relation.setStartNode(start);
    relation.setEndNode(end);
    relation.setRelation(relationName);

    relationRepository.save(relation);
}

通过接口调用这个方法,绑定

海拉

索尔

之间的关系后,查询结果:

文本 SPO 抽取

在项目中构建知识图谱时,很大一部分场景是基于非结构化的数据,而不是由我们手动输入确定图谱中的节点或关系。因此,我们需要基于文本进行知识抽取的能力,简单来说就是要在一段文本中抽取出 SPO 主谓宾三元组,来构成图谱中的点和边。

这里我们借助 Git 上一个现成的工具类,来进行文本的语义分析和 SPO 三元组的抽取工作,项目地址:

https://download.csdn.net/download/m0_37935175/86578896

这个项目虽然比较简单一共就两个类两个资源文件,但其中的工具类却能够有效帮助我们完成句子中的主谓宾的提取,使用它前需要先引入依赖的坐标:

<dependency>
    <groupId>com.hankcs</groupId>
    <artifactId>hanlp</artifactId>
    <version>portable-1.2.4</version>
</dependency>
<dependency>
    <groupId>edu.stanford.nlp</groupId>
    <artifactId>stanford-parser</artifactId>
    <version>3.3.1</version>
</dependency>

然后把这个项目中

com.hankcs.nlp.lex

包下的两个类拷到我们的项目中,把

resources

下的

models

目录拷贝到我们的

resources

下。

完成上面的步骤后,调用

MainPartExtractor

工具类中的方法,进行一下简单的文本 SPO 抽取测试:

public void mpTest(){
    String[] testCaseArray = {
            "我一直很喜欢你",
            "你被我喜欢",
            "美丽又善良的你被卑微的我深深的喜欢着……",
            "小米公司主要生产智能手机",
            "他送给了我一份礼物",
            "这类算法在有限的一段时间内终止",
            "如果大海能够带走我的哀愁",
            "天青色等烟雨,而我在等你",
            "我昨天看见了一个非常可爱的小孩"
    };
    for (String testCase : testCaseArray) {
        MainPart mp = MainPartExtractor.getMainPart(testCase);
        System.out.printf("%s   %s   %s \n",
                GraphUtil.getNodeValue(mp.getSubject()),
                GraphUtil.getNodeValue(mp.getPredicate()),
                GraphUtil.getNodeValue(mp.getObject()));
    }
}

在处理结果

MainPart

中,比较重要的是其中的

subject

predicate

object

三个属性,它们的类型是

TreeGraphNode

,封装了句子的主谓宾语成分。下面我们看一下测试结果:

可以看到,如果句子中有明确的主谓宾语,那么则会进行抽取。如果某一项为空,则该项为

null

,其余句子结构也能够正常抽取。

动态构建知识图谱

在上面的基础上,我们就可以在项目中动态构建知识图谱了,新建一个

TextAnalysisServiceImpl

,其中实现两个关键方法。

首先是根据句子中抽取的主语或宾语在 Neo4j 中创建节点的方法,这里根据节点的

name

判断是否为已存在的节点,如果存在则直接返回,不存在则添加:

private Node addNode(TreeGraphNode treeGraphNode){
    String nodeName = GraphUtil.getNodeValue(treeGraphNode);

    Node existNode = nodeRepository.findByName(nodeName);
    if (Objects.nonNull(existNode))
        return existNode;

    Node node =new Node();
    node.setName(nodeName);
    return nodeRepository.save(node);
}

然后是核心方法,说白了也很简单,参数传进来一个句子作为文本先进行 spo 的抽取,对实体进行

Node

的保存,再查看是否已经存在同名的关系,如果不存在则创建关联关系,存在的话则不重复创建。下面是关键代码:

@Override
public List<Relation> parseAndBind(String sentence) {
    MainPart mp = MainPartExtractor.getMainPart(sentence);

    TreeGraphNode subject = mp.getSubject();    //主语
    TreeGraphNode predicate = mp.getPredicate();//谓语
    TreeGraphNode object = mp.getObject();      //宾语

    if (Objects.isNull(subject) || Objects.isNull(object))
        return null;

    Node startNode = addNode(subject);
    Node endNode = addNode(object);
    String relationName = GraphUtil.getNodeValue(predicate);//关系词

    List<Relation> oldRelation = relationRepository
            .findRelation(startNode, endNode,relationName);
    if (!oldRelation.isEmpty())
        return oldRelation;

    Relation botRelation=new Relation();
    botRelation.setStartNode(startNode);
    botRelation.setEndNode(endNode);
    botRelation.setRelation(relationName);
    Relation relation = relationRepository.save(botRelation);

    return Arrays.asList(relation);
}

创建一个简单的 controller 接口,用于接收文本:

@GetMapping("parse")
public List<Relation> parse(String sentence) {
    return textAnalysisService.parseAndBind(sentence);
}

接下来,我们从前端传入下面几个句子文本进行测试:

海拉又被称为死亡女神
死亡女神捏碎了雷神之锤
雷神之锤属于索尔

调用完成后,我们再来看看 Neo4j 中的图形关系,可以看到海拉死亡女神索尔这些实体被关联在了一起:

到这里,一个简单的文本处理和图谱创建的流程就被完整的串了起来,但是这个流程还是比较粗糙

标签: 知识图谱

本文转载自: https://blog.csdn.net/m0_37935175/article/details/126957210
版权归原作者 $懒小猿$ 所有, 如有侵权,请联系我们删除。

“SpringBoot 整合 Neo4j”的评论:

还没有评论