如何通过并行化总结文本

LLM 可以总结和提取文本中的所需信息，包括大量文本。在许多情况下，特别是当文本量相对于模型上下文窗口的大小较大时，将摘要任务分解为较小的组件可能很有帮助（或必要）。

Map-reduce 代表了实现此目的的一类策略。其思想是将文本分解为“子文档”，然后首先使用 LLM 将每个子文档映射到单个摘要。然后，我们将这些摘要归约或整合为单个全局摘要。

请注意，映射步骤通常在输入文档上并行化。当对子文档的理解不依赖于先前的上下文时，此策略尤其有效。例如，当总结大量较短文档的语料库时。

LangGraph 构建于 langchain-core 之上，支持 map-reduce 工作流程，非常适合此问题

LangGraph 允许流式传输各个步骤（例如连续摘要），从而可以更好地控制执行；
LangGraph 的 checkpointing 支持错误恢复、扩展人工干预工作流程以及更轻松地集成到对话应用程序中。
LangGraph 实现易于修改和扩展。

下面，我们将演示如何通过 map-reduce 策略总结文本。

加载聊天模型

让我们首先加载一个聊天模型

选择聊天模型

pip install -qU "langchain[openai]"

import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
  os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain.chat_models import init_chat_model

llm = init_chat_model("gpt-4o-mini", model_provider="openai")

加载文档

首先，我们加载文档。我们将使用 WebBaseLoader 加载一篇博客文章，并将文档拆分为更小的子文档。

from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import CharacterTextSplitter

text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
    chunk_size=1000, chunk_overlap=0
)

loader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")
docs = loader.load()

split_docs = text_splitter.split_documents(docs)
print(f"Generated {len(split_docs)} documents.")

API 参考:WebBaseLoader | CharacterTextSplitter

Created a chunk of size 1003, which is longer than the specified 1000
``````output
Generated 14 documents.

创建图

映射步骤

让我们首先定义与映射步骤相关的提示，并通过链将其与 LLM 关联

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

map_prompt = ChatPromptTemplate.from_messages(
    [("human", "Write a concise summary of the following:\\n\\n{context}")]
)

map_chain = map_prompt | llm | StrOutputParser()

API 参考:StrOutputParser | ChatPromptTemplate

归约步骤

我们还定义了一个链，它接受文档映射结果并将它们归约为单个输出。

reduce_template = """
The following is a set of summaries:
{docs}
Take these and distill it into a final, consolidated summary
of the main themes.
"""

reduce_prompt = ChatPromptTemplate([("human", reduce_template)])

reduce_chain = reduce_prompt | llm | StrOutputParser()

通过 LangGraph 编排

下面我们实现一个简单的应用程序，该应用程序将摘要步骤映射到文档列表上，然后使用上述提示将其归约。

当文本长度与 LLM 的上下文窗口相比很长时，Map-reduce 流特别有用。对于长文本，我们需要一种机制来确保归约步骤中要总结的上下文不超过模型的上下文窗口大小。这里我们实现了摘要的递归“折叠”：输入根据 token 限制进行分区，并生成分区摘要。重复此步骤，直到摘要的总长度在所需的限制范围内，从而可以总结任意长度的文本。

我们将需要安装 langgraph

pip install -qU langgraph

import operator
from typing import Annotated, List, Literal, TypedDict

from langchain.chains.combine_documents.reduce import (
    acollapse_docs,
    split_list_of_docs,
)
from langchain_core.documents import Document
from langgraph.constants import Send
from langgraph.graph import END, START, StateGraph

token_max = 1000


def length_function(documents: List[Document]) -> int:
    """Get number of tokens for input contents."""
    return sum(llm.get_num_tokens(doc.page_content) for doc in documents)


# This will be the overall state of the main graph.
# It will contain the input document contents, corresponding
# summaries, and a final summary.
class OverallState(TypedDict):
    # Notice here we use the operator.add
    # This is because we want combine all the summaries we generate
    # from individual nodes back into one list - this is essentially
    # the "reduce" part
    contents: List[str]
    summaries: Annotated[list, operator.add]
    collapsed_summaries: List[Document]
    final_summary: str


# This will be the state of the node that we will "map" all
# documents to in order to generate summaries
class SummaryState(TypedDict):
    content: str


# Here we generate a summary, given a document
async def generate_summary(state: SummaryState):
    response = await map_chain.ainvoke(state["content"])
    return {"summaries": [response]}


# Here we define the logic to map out over the documents
# We will use this an edge in the graph
def map_summaries(state: OverallState):
    # We will return a list of `Send` objects
    # Each `Send` object consists of the name of a node in the graph
    # as well as the state to send to that node
    return [
        Send("generate_summary", {"content": content}) for content in state["contents"]
    ]


def collect_summaries(state: OverallState):
    return {
        "collapsed_summaries": [Document(summary) for summary in state["summaries"]]
    }


# Add node to collapse summaries
async def collapse_summaries(state: OverallState):
    doc_lists = split_list_of_docs(
        state["collapsed_summaries"], length_function, token_max
    )
    results = []
    for doc_list in doc_lists:
        results.append(await acollapse_docs(doc_list, reduce_chain.ainvoke))

    return {"collapsed_summaries": results}


# This represents a conditional edge in the graph that determines
# if we should collapse the summaries or not
def should_collapse(
    state: OverallState,
) -> Literal["collapse_summaries", "generate_final_summary"]:
    num_tokens = length_function(state["collapsed_summaries"])
    if num_tokens > token_max:
        return "collapse_summaries"
    else:
        return "generate_final_summary"


# Here we will generate the final summary
async def generate_final_summary(state: OverallState):
    response = await reduce_chain.ainvoke(state["collapsed_summaries"])
    return {"final_summary": response}


# Construct the graph
# Nodes:
graph = StateGraph(OverallState)
graph.add_node("generate_summary", generate_summary)  # same as before
graph.add_node("collect_summaries", collect_summaries)
graph.add_node("collapse_summaries", collapse_summaries)
graph.add_node("generate_final_summary", generate_final_summary)

# Edges:
graph.add_conditional_edges(START, map_summaries, ["generate_summary"])
graph.add_edge("generate_summary", "collect_summaries")
graph.add_conditional_edges("collect_summaries", should_collapse)
graph.add_conditional_edges("collapse_summaries", should_collapse)
graph.add_edge("generate_final_summary", END)

app = graph.compile()

API 参考:acollapse_docs | split_list_of_docs | Document | Send | StateGraph

LangGraph 允许绘制图结构以帮助可视化其功能

from IPython.display import Image

Image(app.get_graph().draw_mermaid_png())

调用图

在运行应用程序时，我们可以流式传输图以观察其步骤序列。下面，我们将仅打印步骤的名称。

请注意，由于我们在图中有一个循环，因此指定执行的 recursion_limit 可能会很有帮助。当超出指定限制时，这将引发特定错误。

async for step in app.astream(
    {"contents": [doc.page_content for doc in split_docs]},
    {"recursion_limit": 10},
):
    print(list(step.keys()))

['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['collect_summaries']
['collapse_summaries']
['collapse_summaries']
['generate_final_summary']

print(step)

{'generate_final_summary': {'final_summary': 'The consolidated summary of the main themes from the provided documents highlights the advancements and applications of large language models (LLMs) in artificial intelligence, particularly in autonomous agents and software development. Key themes include:\n\n1. **Integration of LLMs**: LLMs play a crucial role in enabling autonomous agents to perform complex tasks through advanced reasoning and decision-making techniques, such as Chain of Thought (CoT) and Tree of Thoughts.\n\n2. **Memory Management**: The categorization of memory into sensory, short-term, and long-term types parallels machine learning concepts, with short-term memory facilitating in-context learning and long-term memory enhanced by external storage solutions.\n\n3. **Tool Use and APIs**: Autonomous agents utilize external APIs to expand their capabilities, demonstrating adaptability and improved problem-solving skills.\n\n4. **Search Algorithms**: Various approximate nearest neighbor search algorithms, including Locality-Sensitive Hashing (LSH) and FAISS, are discussed for enhancing search efficiency in high-dimensional spaces.\n\n5. **Neuro-Symbolic Architectures**: The integration of neuro-symbolic systems, such as the MRKL framework, combines expert modules with LLMs to improve problem-solving, particularly in complex tasks.\n\n6. **Challenges and Innovations**: The documents address challenges like hallucination and inefficient planning in LLMs, alongside innovative methods such as Chain of Hindsight (CoH) and Algorithm Distillation (AD) for performance enhancement.\n\n7. **Software Development Practices**: The use of LLMs in software development is explored, particularly in creating structured applications like a Super Mario game using the model-view-controller (MVC) architecture, emphasizing task management, component organization, and documentation.\n\n8. **Limitations of LLMs**: Constraints such as finite context length and challenges in long-term planning are acknowledged, along with concerns regarding the reliability of natural language as an interface.\n\nOverall, the integration of LLMs and neuro-symbolic architectures signifies a significant evolution in AI, with ongoing research focused on enhancing planning, memory management, and problem-solving capabilities across various applications.'}}

下一步

查看 LangGraph 文档，了解有关使用 LangGraph 构建的详细信息，包括本指南，其中详细介绍了 LangGraph 中的 map-reduce。

请参阅摘要操作指南，了解其他摘要策略，包括专为处理大量文本而设计的策略。

另请参阅本教程，了解有关摘要的更多详细信息。

加载聊天模型​

加载文档​

创建图​

映射步骤​

归约步骤​

通过 LangGraph 编排​

调用图​

下一步​

此页对您有帮助吗？

加载聊天模型

加载文档

创建图

映射步骤

归约步骤

通过 LangGraph 编排

调用图

下一步