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

AGI｜基于LangChain实现的三种高级RAG检索方法_langchain 高级rag

作者：知新_RL | 2024-06-16 02:01:07

赞

踩

langchain 高级rag

一、前言

RAG(Retrieval-Augmented Generation)检索增强生成，是现如今基于企业私域知识的问答应用所使用的主流技术之一。相较于重新训练基于私域知识的大模型来说，RAG没有额外的预训练成本，且回答效果与之相当。

但在实际应用场景中，RAG所面临最大的问题是LLM的上下文长度限制。企业私域知识文本的数量十分庞大，不可能将其全部放在模型的prompt中，即使现在各类模型已经将上下文token从年初的2k、4k扩充到了128k、192k，但是这可能也就是一份合同、一份标书的长度。因此，如何减少传递给模型的内容数量且同时提高内容质量，是提升基于RAG的AI应用回答准确度的一个重要方法。

本篇文章将基于LangChain实现三种高级检索方法，句子窗口检索和自动合并检索旨在改善RAG流程的召回过程中存在的信息残缺的问题，而多路召回检索则保证了在多个文档中检索召回的准确性。

二、先验知识

●RAG简要流程

加载文档——切分划片——嵌入为向量表示——存入数据库

向量化问题——向量召回文档——合并放入Prompt——LLM生成答案

三、句子窗口检索

（一）概念

在文档进行切片工作后，文档被分为若干个Langchain自定义的Document对象，该对象有两个属性，一是page_content即该切片的文本内容，二是meta_data即有关该切片的一些信息和可自定义封装进入的信息。

句子窗口检索方法，将每个切片的相邻切片的内容封装在切片的meta_data中。在检索和召回过程时，根据命中文档的meta_data可获得此段落的上下文信息，并将其封装进入命中文档的page_content中。组合完成的文档列表即可作为prompt交付给大模型生成。

在实际问答任务中，我们建议使用切片器将文档切分为较短的分片，或使用依据标点符号进行切分的切片器。保证整片文档拥有较细的颗粒度。同时在封装和召回阶段，适当扩大窗口大小，保证召回段落的完整性。

（二）BERT

（1）元数据封装

  1. def metadata_format(self, ordered_text, **kwargs):
  2. count = kwargs.get("split_count", 1)
  3. fori, documentinenumerate(ordered_text):
  4. ifi > 0:
  5. document.metadata['previous_page'] = ordered_text[i-count].page_content
  6. else:
  7. document.metadata['previous_page'] = ''
  8.  
  9. ifi < len(ordered_text) - 1:
  10. document.metadata['next_page'] = ordered_text[i+count].page_content
  11. else:
  12. document.metadata['next_page'] = ''
  13. returnordered_text

（2）数据重构

  1. def search_and_format(self, databases, query, **kwargs):
  2. top_documents = []
  3. fordb in databases:
  4. top_documents.append(db.similarity_search_with_score(query))
  5. docs = []
  6. fordoc, _ in top_documents:
  7. doc.page_content = doc.metadata.get("previous_page") + doc.page_content + doc.metadata.get("next_page")
  8. docs.append(doc)
  9. returndocs

（3）调用示例伪代码

  1. #load document
  2. ......
  3.  
  4. #split
  5. ......
  6. #use smartvision sdk to format
  7. sentence_window_retrival = SentenceWindow()
  8. formatted_documents = sentence_window_retrival.metadata_format(documents, split_count=2)
  9.  
  10. #embedding 
  11. ......
  12.  
  13. #load inlocalvector db
  14. ......
  15.  
  16. #use smartvision sdk to dosearch and multiple recall
  17. databases = [db]
  18. query = "烟草专卖品的运输"
  19. top_documents = sentence_window_retrival.search_and_format(databases, query)
  20. print(top_documents)

四、自动合并检索

（一）概念

自动合并检索方法，实现方法源自Llamaindex所封装的自动合并检索，但RAG全流程需要制定一套准确的规范，因此在用户文档完成读取和切片工作后，所得到的Langchain格式的Document对象需转化为Llamaindex定义的Document对象，便可通过Llamaindex的自定义算法自动划分整个切片列表的子节点和父节点，最后鉴于规范再重新转化为Langchain格式的Document对象，并将父节点信息、深度信息等封装进每个节点。

在检索阶段，召回最相关的若干个节点，遍历这些节点和附加信息，如若超过K个节点同时属于同一个节点（这里的K为用户自定义阈值，通常为一个节点所有子节点的半数）则执行合并该父节点下属所有子节点，即返回整个父节点内容。这使我们能够将可能不同的较小上下文合并到一个可能有助于综合的更大上下文中。

（二）代码实现和调用

（1）元数据封装

  1. defauto_merge_format(documents, **kwargs):
  2. ifdocuments isNone:
  3. raiseValueError('documents is required')
  4. formatted_documents = []
  5. doc_text = "\n\n".join([d.page_content ford indocuments])
  6. docs = [Document(text=doc_text)]
  7. node_parser = HierarchicalNodeParser.from_defaults(chunk_sizes=kwargs.get("pc_chunk_size", [2048, 512, 128]),chunk_overlap=kwargs.get("pc_chunk_overlap", 10))
  8. nodes = node_parser.get_nodes_from_documents(docs)
  9. leaf_nodes = get_leaf_nodes(nodes)
  10. root_nodes = get_root_nodes(nodes)
  11. middle_nodes = get_middle_node(nodes, leaf_nodes, root_nodes)
  12. root_context_dict = {}
  13. forroot_node innodes:
  14. root_context_dict[root_node.node_id] = root_node.get_content()
  15.  
  16. fornode innodes:
  17. ifnode.parent_node:
  18. node_id = node.node_id
  19. root_node_id = node.parent_node.node_id
  20. root_node_content = root_context_dict.get(node.parent_node.node_id)
  21. root_node_child_count = 0
  22. forparent_node inroot_nodes + middle_nodes:
  23. ifparent_node.node_id == node.parent_node.node_id:
  24. root_node_child_count = len(parent_node.child_nodes)
  25. break
  26. depth = 2ifnode inmiddle_nodes else3
  27. child_count = len(node.child_nodes) ifnode.child_nodes isnotNoneelse0
  28. document = langchain.schema.Document(page_content=node.get_content(),metadata={"node_id": node_id, "root_node_id": root_node_id, "root_node_content": root_node_content, "root_node_child_count": root_node_child_count, "depth": depth, "child_count": child_count})
  29. formatted_documents.append(document)
  30. returnformatted_documents

（2）数据重构

  1. defsearch_and_format(self, databases, query, **kwargs):
  2. top_documents = []
  3. fordb indatabases:
  4. top_document = db.similarity_search_with_score(query)
  5. top_documents.append(top_document)
  6. leaf_nodes = [doc fordoc, _ intop_documents]
  7. returndo_merge(leaf_nodes, **kwargs)
  8.  
  9.  
  10. defgroup_nodes_by_depth(nodes, depth):
  11. return[node fornode innodes ifnode.metadata.get("depth") == depth]
  12.  
  13. defprocess_group(nodes, threshold):
  14. grouped_by_root_id = {}
  15. fornode innodes:
  16. root_id = node.metadata.get("root_node_id")
  17. grouped_by_root_id.setdefault(root_id, []).append(node)
  18.  
  19. merge_context = []
  20. forgroup ingrouped_by_root_id.values():
  21. node_count = len(group)
  22. child_count = group[0].metadata.get("root_node_child_count")
  23. ifnode_count / child_count >= threshold:
  24. merge_context.append(langchain.schema.Document(
  25. page_content=group[0].metadata.get("root_node_content")
  26. ))
  27. else:
  28. fordocument ingroup:
  29. merge_context.append(document)
  30. returnmerge_context
  31.  
  32. defdo_merge(nodes, **kwargs)-> List[langchain.schema.Document]:
  33. threshold = kwargs.get("threshold", 0.5)
  34. leaf_nodes = group_nodes_by_depth(nodes, 3)
  35. middle_nodes = group_nodes_by_depth(nodes, 2)
  36. leaf_merge_context = process_group(leaf_nodes, threshold)
  37. middle_merge_context = process_group(middle_nodes, threshold)
  38. merge_content = leaf_merge_context + middle_merge_context
  39. returnmerge_content
  40.  
  41. defget_middle_node(nodes, leaf_nodes, root_nodes):
  42. middle_node = []
  43. fornode innodes:
  44. ifnode notinleaf_nodes andnode notinroot_nodes:
  45. middle_node.append(node)
  46. returnmiddle_node

（3）调用示例伪代码

  1. #load document
  2. ......
  3.  
  4. #split
  5. ......
  6.  
  7. #use smartvision sdk to format
  8. auto_merge_retrival = AutoMergeRetrieval()
  9. formatted_documents = auto_merge_retrival.metadata_format(documents,
  10. pc_chunk_size=[1024, 128, 32],
  11. pc_chunk_overlap=4)
  12. #embedding 
  13. ......
  14.  
  15. #load inlocalvector db
  16. ......
  17.  
  18. #use smartvision sdk to dosearch and multiple recall
  19. top_documents = auto_merge_retrival.search_and_format(databases, query, threshold=0.5)
  20. print(top_documents)

五、多路召回检索

（一）概念

多路召回检索方法，在元数据封装环节并未做任何操作，而在检索阶段他允许用户上传多个数据集或不同类型的向量数据库作为检索对象，以适应用户私域知识库文档类型不同，文档数量庞大的问题。从多个数据源检索得到文档列表，而后通过rerank模型对文档与问题的相关性进行评分，筛选出大于一定分值的文档，组合成为prompt。

由此可见，多路召回检索在数据源广而杂的情况下，富有更好的效果。此外，rerank模型虽能进行再次的重排以提高准确性，但是在牺牲速度和效率的前提下进行的，因此需充分考虑这个问题。

（二）代码实现

（1）元数据封装

  1. defmetadata_format(self, ordered_text, **kwargs):
  2. """
  3. 默认rag，不做任何处理
  4. """
  5. returnordered_text

（2）数据重构

  1. defsearch_and_format(self, databases, query, **kwargs):
  2. top_documents = []
  3. result_data = []
  4. fordb indatabases:
  5. top_document = db.similarity_search_with_score(query)
  6. top_documents.append(top_document)
  7. pairs = [[query, item.page_content] foritem intop_documents]
  8. withtorch.no_grad():
  9. rerank_tokenizer = AutoTokenizer.from_pretrained(RERANK_FILE_PATH)
  10. inputs = rerank_tokenizer(pairs, padding=True, truncation=True, return_tensors='pt', max_length=512)
  11. rerank_model = AutoModelForSequenceClassification.from_pretrained(RERANK_FILE_PATH)
  12. scores = rerank_model(**inputs, return_dict=True).logits.view(-1, ).float()
  13. fori, score inenumerate(scores):
  14. data = {
  15. "text": top_documents[i].page_content,
  16. "score": float(score)
  17. }
  18. result_data.append(data)
  19. returnresult_data

六、结语

本文提供的三种高级RAG检索方法，但仅改善了流程中检索召回环节的信息残缺问题，实质上RAG全流程均存在各种优化方法，但最有效的方法仍是改进或提供新的召回方式。

总结以上三种方法，均需要重点注意切片器的选用并控制切片大小，过大导致上下文长度过长，且有研究表明过长的prompt易使大模型忽略的中间部分的信息。过短则导致关键信息残缺，无法为大模型提供有效的上下文。因此开发者需根据文档类型和结构，谨慎选择并适当调节优化。

神州数码集团的神州问学平台不仅提供了本文所述的三种高级检索方法的SDK，而且我们的开发团队正不断探索和研发新的、更高效的检索技术。我们致力于满足客户对于多样化私域知识库结构的需求，以实现更精准、更全面的搜索体验。同时，我们也欢迎您体验平台并提供宝贵意见。

作者：孙泽文| 神州数码云基地

更多AI小知识欢迎关注“神州数码云基地”公众号，回复“AI与数字化转型”进入社群交流

版权声明：文章由神州数码武汉云基地团队实践整理输出，转载请注明出处。

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

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

  

闽ICP备14008679号