知识图谱从三元组到GraphRAG：构建与推理一篇搞懂

知识图谱概念虽已提出多年，真正落地并产生实效的团队仍属少数。从最基础的三元组结构，到近期备受关注的GraphRAG，整个技术栈涵盖了知识表示、知识构建与知识推理三大环节。本文沿这条主线，系统梳理知识图谱的完整技术体系。

一、什么是知识图谱？

1.1 核心定义

简而言之，知识图谱是以图结构组织知识的系统。其基本构件包括三个：

• 节点：代表实体，如人物、地点、组织或抽象概念。
• 边：代表关系，描述实体间的关联方式，例如“出生于”“创立了”“属于”。
• 属性：实体的具体特征，如年龄38岁、人口1400万等细节信息。

最小知识单元称为三元组：

(头实体, 关系, 尾实体)

实例说明：

1.2 知识图谱 vs 普通数据库

两者本质差异在于：关系数据库存储数据，知识图谱存储知识。数据静态，知识动态——能推理、能发现、能解释。

二、知识图谱全景图

整个知识图谱技术栈可拆分为三大支柱：

三、知识表示：两种主流模型

3.1 RDF三元组模型

RDF是W3C制定的标准表示模型，每条知识构成一个三元组，实体与关系均以URI标识。查询语言为SPARQL。

示例（Turtle格式）：

@prefix ex:  .
ex:DeepSeek ex:locatedIn ex:China .
ex:DeepSeek ex:develops ex:LLM .
ex:LLM ex:basedOn ex:Transformer .
ex:Transformer ex:proposedBy ex:Google .
ex:Transformer ex:proposedIn "2017"^^xsd:integer .

优势显著：标准统一、语义丰富、原生支持推理。不足在于属性表示不够直接，查询编写复杂度较高。

3.2 属性图模型

Neo4j采用的模型，直观性更强。节点携带标签和属性，关系同样支持类型与属性，查询语言为Cypher。

CREATE (d:Company {name: 'DeepSeek', founded: 2023})
CREATE (c:Country {name: '中国'})
CREATE (l:Technology {name: 'LLM'})
CREATE (t:Architecture {name: 'Transformer', year: 2017})
CREATE (g:Company {name: 'Google'})
CREATE (d)-[:LOCATED_IN]->(c)
CREATE (d)-[:DEVELOPS]->(l)
CREATE (l)-[:BASED_ON]->(t)
CREATE (t)-[:PROPOSED_BY]->(g)

直观、属性丰富、生态成熟是其长处，但非W3C标准，跨平台互操作性稍弱。

3.3 两种模型对比

四、知识构建：从文本到图谱

4.1 知识抽取

从非结构化文本中提取三元组，是构建知识图谱的第一步。包含三个子任务：

到2026年，利用LLM辅助抽取已成为主流做法，例如：

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template("""
从以下文本中抽取知识三元组，格式为 (头实体, 关系, 尾实体)：
文本: {text}
输出格式:
- (实体1, 关系, 实体2)
- (实体3, 关系, 实体4)
...
""")

llm = ChatOpenAI(model="gpt-4o-mini")
chain = prompt | llm

text = "DeepSeek是一家位于中国的AI公司，由梁文锋创立，开发了DeepSeek-V3大语言模型"
result = chain.invoke({"text": text})
print(result.content)
# 输出:
# - (DeepSeek, 位于, 中国)
# - (DeepSeek, 创始人, 梁文锋)
# - (DeepSeek, 开发了, DeepSeek-V3)
# - (DeepSeek-V3, 类型, 大语言模型)

4.2 知识融合

多源知识合并需处理几个典型问题：

4.3 知识推理

推理是知识图谱的核心能力——从已知知识推导未知知识。当前主流方法有四种：

五、知识嵌入：把图谱变成向量

5.1 为什么需要嵌入？

知识图谱本质上是符号系统，机器无法直接进行数值计算和推理。知识嵌入（KGE）将实体与关系映射为低维向量，使机器能够计算、比较和推理。

5.2 三大嵌入家族

翻译模型

核心思路：头实体向量 + 关系向量 ≈ 尾实体向量。公式表达：

f(h, r, t) = ||h + r - t||

语义匹配模型

通过双线性或内积衡量三元组合理性：

f(h, r, t) = hᵀMᵣt

图神经网络

核心是通过消息传递聚合邻居信息：

hᵥ⁽ˡ⁺¹⁾ = σ(∑ᵣ ∑ᵤ∈Nᵣ(v) Wᵣ⁽ˡ⁾ hᵤ⁽ˡ⁾)

5.3 代码实战：TransE训练

import torch
import torch.nn as nn

class TransE(nn.Module):
    def __init__(self, num_entities, num_relations, dim=128, margin=1.0):
        super().__init__()
        self.entity_emb = nn.Embedding(num_entities, dim)
        self.relation_emb = nn.Embedding(num_relations, dim)
        self.margin = margin
        nn.init.xa vier_uniform_(self.entity_emb.weight)
        nn.init.xa vier_uniform_(self.relation_emb.weight)

    def forward(self, h, r, t):
        h_emb = self.entity_emb(h)
        r_emb = self.relation_emb(r)
        t_emb = self.entity_emb(t)
        h_emb = nn.functional.normalize(h_emb, p=2, dim=-1)
        t_emb = nn.functional.normalize(t_emb, p=2, dim=-1)
        score = torch.norm(h_emb + r_emb - t_emb, p=2, dim=-1)
        return score

    def loss(self, pos_score, neg_score):
        return torch.mean(torch.clamp(pos_score - neg_score + self.margin, min=0))

# 训练示例
model = TransE(num_entities=10000, num_relations=100, dim=128)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(100):
    pos_h, pos_r, pos_t = get_positive_batch()
    neg_t = get_negative_samples(pos_t)
    pos_score = model(pos_h, pos_r, pos_t)
    neg_score = model(pos_h, pos_r, neg_t)
    loss = model.loss(pos_score, neg_score)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if epoch % 10 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

# 链接预测
def predict_tail(model, h, r, all_entities):
    h_tensor = torch.tensor([h]).repeat(len(all_entities))
    r_tensor = torch.tensor([r]).repeat(len(all_entities))
    t_tensor = torch.tensor(all_entities)
    scores = model(h_tensor, r_tensor, t_tensor)
    top_k = torch.argsort(scores)[:10]
    return top_k

六、知识查询：Cypher与SPARQL

6.1 Neo4j Cypher查询

// 1. 创建知识图谱
CREATE (ds:Company {name: 'DeepSeek', founded: 2023})
CREATE (cn:Country {name: '中国'})
CREATE (llm:Technology {name: 'LLM'})
CREATE (tf:Architecture {name: 'Transformer', year: 2017})
CREATE (gg:Company {name: 'Google'})
CREATE (rag:Technique {name: 'RAG'})

CREATE (ds)-[:LOCATED_IN]->(cn)
CREATE (ds)-[:DEVELOPS]->(llm)
CREATE (llm)-[:BASED_ON]->(tf)
CREATE (tf)-[:PROPOSED_BY]->(gg)
CREATE (llm)-[:ENHANCED_BY]->(rag)

// 2. 单跳查询
MATCH (d:Company {name: 'DeepSeek'})-[:LOCATED_IN]->(c)
RETURN c.name

// 3. 多跳查询
MATCH (d:Company {name: 'DeepSeek'})-[:DEVELOPS]->()-[:BASED_ON]->()-[:PROPOSED_BY]->(c)
RETURN c.name

// 4. 路径查询
MATCH path = (d:Company {name: 'DeepSeek'})-[*..5]-(g:Company {name: 'Google'})
RETURN path

// 5. 聚合查询
MATCH (c:Country)<-[:LOCATED_IN]-(d:Company)
RETURN c.name, COUNT(d) AS company_count
ORDER BY company_count DESC

6.2 Python + Neo4j实战

from neo4j import GraphDatabase

class KnowledgeGraph:
    def __init__(self, uri="bolt://localhost:7687", user="neo4j", password="password"):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def close(self):
        self.driver.close()

    def add_triple(self, head, relation, tail, head_label="Entity", tail_label="Entity"):
        with self.driver.session() as session:
            session.run(f"""
                MERGE (h:{head_label} {{name: $head}})
                MERGE (t:{tail_label} {{name: $tail}})
                MERGE (h)-[r:{relation}]->(t)
            """, head=head, tail=tail)

    def query(self, cypher, **params):
        with self.driver.session() as session:
            result = session.run(cypher, **params)
            return [record.data() for record in result]

    def multi_hop_query(self, entity, relation_path):
        path = "-".join([f"[:{r}]->(:Entity)" for r in relation_path])
        cypher = f"""
            MATCH (e:Entity {{name: $entity}})-{path}-(target)
            RETURN target.name AS result
        """
        return self.query(cypher, entity=entity)

    def find_paths(self, entity1, entity2, max_depth=5):
        cypher = f"""
            MATCH path = (e1:Entity {{name: $e1}})-[*..{max_depth}]-(e2:Entity {{name: $e2}})
            RETURN [node in nodes(path) | node.name] AS entities, [rel in relationships(path) | type(rel)] AS relations
            LIMIT 10
        """
        return self.query(cypher, e1=entity1, e2=entity2)

# 使用示例
kg = KnowledgeGraph()
kg.add_triple("DeepSeek", "LOCATED_IN", "中国", "Company", "Country")
kg.add_triple("DeepSeek", "DEVELOPS", "LLM", "Company", "Technology")
kg.add_triple("LLM", "BASED_ON", "Transformer", "Technology", "Architecture")
result = kg.multi_hop_query("DeepSeek", ["DEVELOPS", "BASED_ON"])
paths = kg.find_paths("DeepSeek", "Google")

七、GraphRAG：2026年最火的知识图谱应用

7.1 为什么需要GraphRAG？

传统基于向量检索的RAG存在三个难以回避的缺陷：

7.2 GraphRAG架构

整体流程分为五步：

1. 文档输入：获取非结构化文本数据。
2. LLM知识抽取：识别实体、抽取关系，转换为三元组存入Neo4j。
3. 查询处理：用户提问后，先进行实体链接，定位关键实体。
4. 图谱检索：结合Cypher查询、向量搜索与PCST算法，返回最相关子图。
5. LLM生成：将子图与原始问题输入大模型，产出精准答案，推理路径全程可追溯。

7.3 GraphRAG代码实战

from langchain.chat_models import ChatOpenAI
from langchain.graphs import Neo4jGraph
from langchain.chains import GraphCypherQAChain

graph = Neo4jGraph(url="bolt://localhost:7687", username="neo4j", password="password")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
chain = GraphCypherQAChain.from_llm(
    llm=llm,
    graph=graph,
    verbose=True,
    return_intermediate_steps=True
)

result = chain.invoke("DeepSeek的技术基础是谁提出的？")
print(result['result'])
# "Google"
print(result['intermediate_steps'])
# DeepSeek -> DEVELOPS -> LLM -> BASED_ON -> Transformer -> PROPOSED_BY -> Google

7.4 GraphRAG vs 向量RAG对比

八、知识图谱的四大应用场景

8.1 智能问答（KBQA）

直接从知识图谱中查找答案，支持多种问题类型：简单问题单跳即可解决，复杂问题需多跳推理，聚合问题则依赖聚合查询。

8.2 推荐系统

知识图谱为推荐系统带来三项显著改进：冷启动阶段可利用图谱属性进行推荐，可解释性上推荐路径直观可追溯，沿图谱路径探索可有效避免推荐同质化。

8.3 风控与反欺诈

金融风控本质是关联分析。知识图谱在此领域优势突出：能发现隐蔽的关联链路，通过社区检测算法识别欺诈团伙，利用异常模式检测发现异常资金流向。

8.4 GraphRAG（图谱增强生成）

2026年最热门的应用方向。核心思路是利用知识图谱为LLM提供事实校准，确保生成前先查询图谱；多跳推理方面，图谱可完成向量检索无法实现的关联推理；每一步推理均有图结构支撑，可解释性极强。

九、面试高频问题

Q1：知识图谱和关系数据库的本质区别？
三个维度：关系表示上，数据库用外键隐式表示，知识图谱用边显式表示；查询方式上，数据库用JOIN做多表关联，知识图谱用图遍历做多跳查询，更自然；推理能力上，数据库只能查已有数据，知识图谱能通过规则/嵌入/GNN推导新知识。

Q2：TransE的局限性是什么？怎么解决？
TransE假设h+r=t，无法处理1-to-N关系（例如一位导演拍摄多部电影，所有电影向量趋于一致）。解决方案包括TransH投影到超平面、TransR映射到关系空间、RotatE采用复数旋转，其中RotatE效果最佳。

Q3：知识图谱构建中最大的挑战是什么？
三大挑战：知识抽取质量不高，噪声三元组较多；实体对齐困难，不同来源的同一实体需识别和合并；知识更新需求持续。LLM辅助构建是2026年的主流方案，但幻觉问题仍需人工校验。

Q4：GraphRAG和向量RAG怎么选？
简单问答场景选用向量RAG，成本低、构建快；复杂推理场景选用GraphRAG，多跳关联、可解释。实践中可混合使用：向量RAG做初筛，GraphRAG做精排。若知识间存在大量关联关系（如法律、医疗、金融领域），GraphRAG优势明显。

Q5：知识图谱和LLM的关系？
互补关系。LLM擅长理解与生成，但不擅长事实记忆和多跳推理；知识图谱擅长事实存储与关联推理，但不擅长自然语言理解。2026年的趋势是LLM+KG融合：LLM负责从文本中抽取知识构建图谱，图谱负责为LLM提供事实校准和推理支撑。

十、总结

知识图谱的核心可以概括为一句话：用图结构表示知识，从已知推理未知，最终落地到智能应用。

最后牢记一点：知识图谱并非数据库的升级版，而是AI从“语言理解”迈向“知识推理”的关键基础设施。大模型赋予AI理解力，知识图谱赋予AI事实力——两者结合，才是真正可信赖的AI。

来源：互联网