LeanRAG与KAG：知识图谱增强生成框架对比分析
背景与动机
检索增强生成（RAG）通过利用外部知识来增强大型语言模型，但其有效性常常因检索到上下文有缺陷或不完整的信息而受到影响。为解决这一问题，基于知识图谱的RAG方法应运而生，但仍然存在一些关键挑战：
- 语义孤岛问题：高级概念摘要作为断开的”语义孤岛”存在，缺乏跨社区推理所需的显式关系。
- 结构感知缺失：检索过程本身仍然缺乏结构感知，常常退化为低效的平面搜索，无法利用图谱丰富的拓扑结构。
- 推理能力不足：传统RAG对知识的逻辑关系不敏感，难以处理需要复杂推理的专业问题。
- 领域知识缺失：大语言模型在专业领域知识服务中存在局限性，无法满足高准确性和专业性的需求。
为解决这些问题，研究人员提出了LeanRAG和KAG两种知识图谱增强生成框架，它们通过不同的技术路径，提升了大语言模型在专业领域的推理能力和准确性。
LeanRAG框架详解
LeanRAG（Knowledge-Graph-Based Generation with Semantic Aggregation and Hierarchical Retrieval）是一个基于语义聚合与分层检索的知识图谱生成框架，由上海人工智能实验室等机构的研究人员提出。LeanRAG通过深度协作的知识聚合和检索策略，解决了”语义孤岛”和结构-检索不匹配问题。
architecture
核心创新：语义聚合算法
LeanRAG首先采用一种新颖的语义聚合算法，该算法形成实体簇并构建聚合级别摘要之间的新显式关系，创建一个完全可导航的语义网络。这一过程包括：
- 递归语义聚类：利用高斯混合模型（GMM）对实体进行语义聚类，形成语义相关的实体组。
- 聚合实体生成：为每个聚类生成一个更抽象的聚合实体，代表该聚类的集体语义。
- 聚合关系生成：在聚合实体之间创建新的关系，防止在更高层次形成”语义孤岛”。
Python: LeanRAG语义聚合算法伪代码
def semantic_aggregation(graph_layer):
# 步骤1: 语义嵌入
embeddings = {entity: encode(entity.description) for entity in graph_layer.entities}
# 步骤2: 高斯混合聚类
clusters = gmm_clustering(embeddings, num_clusters=m)
# 步骤3: 生成聚合实体
aggregated_entities = []
for cluster in clusters:
relations = get_intra_cluster_relations(cluster)
agg_entity = generate_aggregated_entity(cluster, relations)
aggregated_entities.append(agg_entity)
# 步骤4: 生成聚合关系
aggregated_relations = []
for i, entity_a in enumerate(aggregated_entities):
for j, entity_b in enumerate(aggregated_entities):
if i < j: # 避免重复
inter_cluster_relations = get_inter_cluster_relations(
clusters[i], clusters[j])
if len(inter_cluster_relations) > threshold:
agg_relation = generate_aggregated_relation(
entity_a, entity_b, inter_cluster_relations)
aggregated_relations.append(agg_relation)
return KnowledgeGraph(aggregated_entities, aggregated_relations)
search
核心创新：自底向上、结构引导的检索策略
LeanRAG采用自底向上、结构引导的检索策略，将查询锚定到最相关的细粒度实体，然后系统地遍历图谱的语义路径，收集简洁但上下文全面的证据集。这一策略包括：
- 初始实体锚定：在基础层执行密集检索搜索，识别与查询最语义相似的实体。
- LCA路径遍历：利用最低公共祖先（LCA）原则构建连接种子实体的最小子图。
- 上下文收集：收集LCA路径上的所有实体和关系，形成紧凑且连贯的上下文。
Python: LeanRAG结构化检索策略伪代码
def structured_retrieval(query, hierarchical_graph):
# 步骤1: 初始实体锚定
base_layer = hierarchical_graph.get_base_layer()
seed_entities = top_n_entities(base_layer, query, n=10)
# 步骤2: 找到最低公共祖先
lca = find_lowest_common_ancestor(seed_entities, hierarchical_graph)
# 步骤3: 构建LCA路径
retrieval_paths = []
for entity in seed_entities:
path = shortest_path(hierarchical_graph, entity, lca)
retrieval_paths.append(path)
# 步骤4: 收集检索子图
retrieved_entities = set()
retrieved_relations = set()
for path in retrieval_paths:
for node in path.nodes:
retrieved_entities.add(node)
for edge in path.edges:
retrieved_relations.add(edge)
# 添加聚合层间关系
for layer in hierarchical_graph.layers:
for relation in layer.inter_cluster_relations:
if relation.source in retrieved_entities and relation.target in retrieved_entities:
retrieved_relations.add(relation)
# 步骤5: 返回原始文本块
original_chunks = get_original_chunks(retrieved_entities)
return RetrievalResult(retrieved_entities, retrieved_relations, original_chunks)
KAG框架详解
KAG（Knowledge Augmented Generation）是蚂蚁集团开源的一款知识增强生成框架，基于OpenSPG引擎和大型语言模型，设计了逻辑符号引导的混合推理引擎，将自然语言问题转化为结合语言和符号的问题求解过程，集成了图谱推理、逻辑计算、chunk检索、llm推理四种问题求解过程。
psychology
核心功能：知识表示增强
KAG采用层次化知识表示，将非结构化文本转为结构化知识图谱，定义概念类型、实体类型等数据结构，让知识表示更符合大语言模型理解能力，提升可解释性与应用范围。KAG能够处理非结构化数据、结构化信息和业务专家经验，并将它们融合到统一的业务知识图谱中。
Python: KAG知识表示增强伪代码
class KnowledgeRepresentation:
def __init__(self):
self.concept_types = {} # 概念类型定义
self.entity_types = {} # 实体类型定义
self.relation_types = {} # 关系类型定义
self.attribute_types = {} # 属性类型定义
def add_concept_type(self, name, parent=None, description=""):
"""添加概念类型"""
self.concept_types[name] = {
"parent": parent,
"description": description
}
def add_entity_type(self, name, concept_type, attributes=[]):
"""添加实体类型"""
self.entity_types[name] = {
"concept_type": concept_type,
"attributes": attributes
}
def add_relation_type(self, name, domain, range, description=""):
"""添加关系类型"""
self.relation_types[name] = {
"domain": domain,
"range": range,
"description": description
}
def transform_text_to_kg(self, text):
"""将非结构化文本转换为知识图谱"""
# 1. 实体识别
entities = self.entity_recognition(text)
# 2. 关系抽取
relations = self.relation_extraction(text, entities)
# 3. 属性抽取
attributes = self.attribute_extraction(text, entities)
# 4. 构建知识图谱
kg = self.build_kg(entities, relations, attributes)
return kg
sync_alt
核心功能：知识图谱与文本互索引
KAG实现了知识图谱与原始文本块之间的相互索引，提高了数据检索精确度和效率，增强了知识整合能力。通过语义分块、信息注入和领域知识约束，KAG能够有效提升知识检索和表示效率。互索引构建过程包括：
- 数据来源整合：收集非结构化数据、结构化数据和专家规则数据。
- 知识抽取与结构化：使用信息抽取技术从文本中提取实体、事件、概念和关系等信息。
- 知识语义对齐：对知识图谱中的实体实例进行分类，预测概念之间的超/下位词关系。
- 互索引构建：将原始文本根据语义、段落等因素进行分块，并为每个文本块赋予唯一的标识。
Python: KAG互索引构建伪代码
class MutualIndexing:
def __init__(self, kg, text_chunks):
self.kg = kg # 知识图谱
self.text_chunks = text_chunks # 文本块列表
self.kg_to_text = {} # 知识图谱到文本的映射
self.text_to_kg = {} # 文本到知识图谱的映射
def build_mutual_index(self):
"""构建互索引"""
# 1. 文本分块与标识
self.chunk_and_identify_text()
# 2. 知识抽取与结构化
entities, relations = self.extract_and_structure()
# 3. 知识语义对齐
self.semantic_alignment(entities, relations)
# 4. 构建互索引
self.build_index_mapping(entities, relations)
def chunk_and_identify_text(self):
"""文本分块与标识"""
for i, chunk in enumerate(self.text_chunks):
chunk_id = f"chunk_{i}"
self.text_to_kg[chunk_id] = {
"entities": [],
"relations": [],
"content": chunk
}
def extract_and_structure(self):
"""知识抽取与结构化"""
# 从文本中提取实体和关系
entities = []
relations = []
for chunk_id, chunk_data in self.text_to_kg.items():
# 实体识别
chunk_entities = self.entity_recognition(chunk_data["content"])
entities.extend([(entity, chunk_id) for entity in chunk_entities])
# 关系抽取
chunk_relations = self.relation_extraction(chunk_data["content"], chunk_entities)
relations.extend([(relation, chunk_id) for relation in chunk_relations])
return entities, relations
def build_index_mapping(self, entities, relations):
"""构建索引映射"""
# 构建知识图谱到文本的映射
for entity, chunk_id in entities:
if entity not in self.kg_to_text:
self.kg_to_text[entity] = []
self.kg_to_text[entity].append(chunk_id)
self.text_to_kg[chunk_id]["entities"].append(entity)
# 构建文本到知识图谱的映射
for relation, chunk_id in relations:
if relation not in self.kg_to_text:
self.kg_to_text[relation] = []
self.kg_to_text[relation].append(chunk_id)
self.text_to_kg[chunk_id]["relations"].append(relation)
account_tree
核心功能：逻辑形式引导的混合推理引擎
KAG设计了一种逻辑符号引导的混合推理引擎，有规划、推理和检索三种运算符，可将自然语言问题转化为结合语言和符号的求解过程，集成图谱推理、逻辑计算、chunk检索和llm推理四种问题求解过程，通过符号驱动生成逻辑查询表达式，必要时调用外部知识库。
Python: KAG混合推理引擎伪代码
class HybridReasoningEngine:
def __init__(self, kg, llm):
self.kg = kg # 知识图谱
self.llm = llm # 大语言模型
self.operators = {
"plan": self.plan_operator,
"reason": self.reason_operator,
"retrieve": self.retrieve_operator
}
def solve(self, query):
"""求解问题"""
# 1. 问题理解与规划
plan = self.plan_operator(query)
# 2. 执行推理过程
result = self.execute_plan(plan)
# 3. 生成答案
answer = self.generate_answer(result, query)
return answer
def plan_operator(self, query):
"""规划运算符：将自然语言问题转化为逻辑形式"""
# 使用LLM将自然语言问题转化为逻辑形式
prompt = f"""
将以下自然语言问题转化为逻辑形式查询：
问题：{query}
请输出一个逻辑查询计划，包括：
1. 需要检索的实体和关系
2. 需要执行的推理步骤
3. 需要的计算操作
"""
logic_form = self.llm.generate(prompt)
return self.parse_logic_form(logic_form)
def reason_operator(self, logic_form):
"""推理运算符：执行逻辑推理"""
# 1. 图谱推理
kg_result = self.kg_reasoning(logic_form)
# 2. 逻辑计算
calc_result = self.logical_calculation(logic_form)
# 3. LLM推理
llm_result = self.llm_reasoning(logic_form)
# 整合推理结果
return self.integrate_results(kg_result, calc_result, llm_result)
def retrieve_operator(self, logic_form):
"""检索运算符：检索相关信息"""
# 1. 知识图谱检索
kg_subgraph = self.kg_retrieval(logic_form)
# 2. 文本块检索
text_chunks = self.text_retrieval(logic_form)
# 整合检索结果
return {
"kg_subgraph": kg_subgraph,
"text_chunks": text_chunks
}
def execute_plan(self, plan):
"""执行查询计划"""
context = {"query": plan["query"]}
for step in plan["steps"]:
operator_type = step["operator"]
operator_input = step["input"]
if operator_type in self.operators:
result = self.operators[operator_type](operator_input)
context[step["name"]] = result
return context
两者对比
LeanRAG和KAG都是基于知识图谱的增强生成框架，但它们在技术架构、推理能力和应用场景等方面存在一些差异。下面从几个关键维度对两者进行对比：
| 对比维度 | LeanRAG | KAG |
|---|---|---|
| 开发机构 | 上海人工智能实验室等 | 蚂蚁集团 |
| 核心引擎 | 自定义知识图谱引擎 | 基于OpenSPG引擎 |
| 知识表示 | 分层知识图谱，通过语义聚合算法构建 | 层次化知识表示，兼容无模式和有模式约束 |
| 检索策略 | 自底向上、基于LCA的结构化检索 | 知识图谱与文本互索引，逻辑形式引导的混合检索 |
| 推理能力 | 支持多跳推理，通过LCA路径遍历实现 | 支持复杂逻辑推理，集成图谱推理、逻辑计算、chunk检索和LLM推理 |
| 技术架构 | 语义聚合算法 + 结构引导检索策略 | KGBuilder + KGSolver + KAGModel |
| 应用场景 | 通用QA任务，多跳问答 | 专业领域知识服务，如医疗、金融、法律等 |
| 性能表现 | 在Mix数据集上总体质量得分8.59±0.01，减少46%检索冗余 | 在电子政务问答准确率91.6%，医疗问答指标解读准确率90%以上 |
| 开源情况 | 已开源，GitHub: https://github.com/RaZzzyz/LeanRAG | 已开源，GitHub: https://github.com/OpenSPG/KAG |
总结与展望
LeanRAG与KAG的核心贡献与未来发展方向
LeanRAG和KAG作为两种先进的知识图谱增强生成框架，分别从不同角度解决了传统RAG方法的局限性，为大语言模型在专业领域的应用提供了新的可能性。
核心贡献
- LeanRAG通过语义聚合算法和自底向上、结构引导的检索策略，解决了”语义孤岛”和结构-检索不匹配问题，实现了高效的知识检索和推理。
- KAG通过知识表示增强、知识图谱与文本互索引、逻辑形式引导的混合推理引擎等技术，提升了大语言模型在专业领域的推理能力和准确性。
未来发展方向
- 知识表示与构建：进一步优化知识表示方法，提高知识图谱的构建效率和质量，支持更多类型的知识和关系。
- 推理能力增强：增强框架的推理能力，支持更复杂的逻辑推理和多跳推理，提高推理的准确性和效率。
- 多模态融合：支持多模态数据的处理和融合，如图像、音频、视频等，扩展框架的应用范围。
- 领域自适应：提高框架在不同领域的自适应能力，降低领域适配的成本和难度。
- 性能优化：优化框架的性能，提高检索和推理的效率，降低资源消耗。
总的来说，LeanRAG和KAG代表了知识图谱增强生成领域的两个重要方向，它们的发展将推动大语言模型在专业领域的应用，为人工智能的发展带来新的可能性。