LeanRAG与KAG：知识图谱增强生成框架对比分析

背景与动机

检索增强生成（RAG）通过利用外部知识来增强大型语言模型，但其有效性常常因检索到上下文有缺陷或不完整的信息而受到影响。为解决这一问题，基于知识图谱的RAG方法应运而生，但仍然存在一些关键挑战：

语义孤岛问题：高级概念摘要作为断开的”语义孤岛”存在，缺乏跨社区推理所需的显式关系。
结构感知缺失：检索过程本身仍然缺乏结构感知，常常退化为低效的平面搜索，无法利用图谱丰富的拓扑结构。
推理能力不足：传统RAG对知识的逻辑关系不敏感，难以处理需要复杂推理的专业问题。
领域知识缺失：大语言模型在专业领域知识服务中存在局限性，无法满足高准确性和专业性的需求。

为解决这些问题，研究人员提出了LeanRAG和KAG两种知识图谱增强生成框架，它们通过不同的技术路径，提升了大语言模型在专业领域的推理能力和准确性。

LeanRAG框架详解

LeanRAG（Knowledge-Graph-Based Generation with Semantic Aggregation and Hierarchical Retrieval）是一个基于语义聚合与分层检索的知识图谱生成框架，由上海人工智能实验室等机构的研究人员提出。LeanRAG通过深度协作的知识聚合和检索策略，解决了”语义孤岛”和结构-检索不匹配问题。

核心创新：语义聚合算法

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)

核心创新：自底向上、结构引导的检索策略

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推理四种问题求解过程。

核心功能：知识表示增强

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

核心功能：知识图谱与文本互索引

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)

核心功能：逻辑形式引导的混合推理引擎

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代表了知识图谱增强生成领域的两个重要方向，它们的发展将推动大语言模型在专业领域的应用，为人工智能的发展带来新的可能性。