作者： C3P00

在大语言模型（LLMs）的领域中，处理长文本的能力对于多轮对话、代码生成和文档摘要等任务变得越来越关键。今天，我们要深入探讨一种名为 E2LLM（Encoder Elongated Large Language Models）的创新方法，它为解决长文本处理中的难题带来了新的突破。

一、背景与挑战

理解和推理长文本对于大语言模型至关重要，尤其是在多轮对话、多仓库代码生成和多文档摘要等任务中。这些任务通常需要处理数千甚至数百万个标记，以确保连贯性和准确性。同时，为了提高大语言模型的性能，有效激活特定领域知识的技术，如思维链推理、上下文学习和检索相关文档等，也增加了对更长序列长度的需求。

然而，要同时实现长上下文的强性能、降低计算复杂性以及利用预训练模型，面临着巨大的挑战，这被称为 “不可能三角”。目前，该领域的研究主要集中在三个方向：修改位置嵌入、注意力机制和长输入序列本身。

二、E2LLM 方法详解

1. 模型架构

E2LLM 框架由四个关键组件组成：分块器（Chunker）、文本编码器（Text Encoder）、适配器（Adapter）和大语言模型解码器（LLM Decoder）。

• 分块器：负责将长文本分成较小的可管理块，确保每个块的标记长度不超过文本编码器的最大序列长度。
• 文本编码器：输入每个块后生成相应的嵌入向量。为了克服预训练编码器可能丢弃对大语言模型解码器回答查询有用信息的问题，采用了低秩适应（LoRA）方法使编码器在对齐过程中可训练。
• 适配器：用于将编码器的输出映射到大语言模型解码器的输入嵌入中，采用两层多层感知机（MLP）和 GELU 激活函数作为适配器网络。
• 大语言模型解码器：将块标记和与提示和查询对应的文本标记连接在一起，让大语言模型生成查询的答案。在实验中，选择了 Llama2 作为大语言模型解码器，并使用 LoRA 进一步训练解码器。

2. 训练任务

• 理解任务：让大语言模型接收来自适配器的块标记后，重述或重建输入，以提高大语言模型对输入的理解。
• 推理任务：使大语言模型基于块标记和用户查询生成答案。

3. 与其他方法的关系

• 与视觉语言模型（VLMs）的关系：E2LLM 受视觉语言模型的启发，通过适配器将预训练的文本编码器与大语言模型解码器对齐，使大语言模型能够解释文本编码器编码的句子并进行推理。
• 与检索增强生成（RAG）的关系：RAG 可以通过检索最相关的段落来增强 E2LLM，而 E2LLM 可以扩展 RAG 中生成器的上下文长度，并解决 RAG 中检索器和生成器解释文本不一致的问题。
• 与 LLoCO 的关系：LLoCO 利用自动压缩器作为长文本编码器，省略了适配器。相比之下，E2LLM 可以并行处理所有块，更适合处理长文本，并且更容易整合更强的文本编码器和大语言模型解码器。

三、实验与结果

在文档问答和文档摘要两个关键任务上，将 E2LLM 与四个基线方法进行比较，包括 YaRN、LongLoRA、RAG 和 LLoCO。实验结果表明，E2LLM 在所有方法中始终取得最佳或次佳性能。

1. 数据集与评估指标

• 数据集：使用五个公开数据集，涵盖摘要和文档问答任务，包括 QMSum、GovReport、Quality、NarrativeQA 和 TriviaQA。
• 评估指标：对于摘要任务，使用 Rouge 指标评估生成文本与参考文本的重叠程度；对于文档问答任务，计算生成答案与参考答案的精确率、召回率和 F1 值。

2. 性能比较

• E2LLM 在所有数据集上的性能优于或与其他方法相当。YaRN 和 LongLoRA 在长序列上会出现内存溢出问题，并且在短序列上性能不佳。原始的 Llama2-7B-Chat 在问答任务上表现较差，主要是由于其上下文长度有限。RAG 在问答任务中表现最差，可能是因为丢失了特定查询所需的关键信息。LLoCO 在问答任务中表现较好，但在摘要任务中性能下降。

3. 推断效率

E2LLM 在推断效率方面表现出色，具有最低的运行时间和内存使用。相比之下，YaRN 和 LongLoRA 由于在推断过程中具有二次方的空间复杂度，资源消耗较高。LLoCO 也通过软提示压缩减少了推断时间，但不如 E2LLM 压缩能力强，并且处理块的方式是顺序的。

4. 消融研究

通过在 QMSum 和 NarrativeQA 数据集上进行消融研究，验证了 “理解” 任务、编码器和解码器的训练以及更换分块器、文本编码器和大语言模型解码器对 E2LLM 性能的影响。结果表明，“理解” 任务对性能至关重要，训练编码器和解码器的 LoRA 分支也很重要，并且使用更先进的编码器和解码器可以提高 E2LLM 的性能。

5. 超参数敏感性

研究了 “理解” 任务的权重、编码器和解码器的 LoRA 秩以及适配器网络的层数等超参数对 E2LLM 性能的影响。结果表明，不同数据集的最佳权重可能不同，编码器和解码器的秩在一定范围内增加可以提高性能，但超过最佳范围会导致过拟合。两层 MLP 的适配器网络在不同数据集上表现稳定。

四、结论

E2LLM 是一种有效的长文本处理方法，它通过将长文本分成块、压缩成嵌入向量并使用适配器与大语言模型解码器对齐，解决了长文本处理中的 “不可能三角” 问题。实验结果表明，E2LLM 在长文本场景中表现出卓越的性能，为大语言模型的长文本处理提供了新的思路和方法。

在人工智能领域，追求建立一个具备人类级智能的代理一直是学术界的宏伟愿景。随着大型语言模型（Large Language Models, LLM）的出现，我们在多个任务上看到了其强大的解决能力。然而，绝大多数基于LLM的代理仍然依赖于手工设计的提示与策略，使其在动态和复杂的环境中显得力不从心。本文将深入探讨一种新型代理——Agent-Pro，它通过策略级反射与优化来实现自我学习和进化，展现了在复杂环境中更为理性的决策能力。

🤖 非人类级智能体的困境

尽管LLM在各种任务中表现优异，但大多数基于法学硕士的代理仍是为特定任务设计的复杂提示工程，使其在处理动态场景时显得笨拙。例如，在信息不完全的多人博弈中，代理无法从交互中学习或调整策略，这与人类通过经验不断优化决策的能力形成鲜明对比。为此，如何让代理具备类似人类的学习与适应能力，成为了一个重要的研究课题。

🧩 Agent-Pro的构建理念

Agent-Pro的核心理念是通过动态信念生成与策略反思来进行自我优化。与传统的代理不同，Agent-Pro不仅在行动层面进行反思，还在策略层面上进行反思。其工作机制可以简单地描述为：在观察到环境信息后，Agent-Pro首先更新自身的信念，然后通过对过去轨迹的反思和优化，生成新的决策策略。

如图1所示，Agent-Pro根据自身与环境的信息构建信念，并通过对信念的反思不断调整行为策略。这一过程使其能够适应复杂动态场景，例如多人德州扑克和21点等游戏。

🌀 策略级反思与优化

Agent-Pro的创新之处在于其引入了策略级反思机制。这个机制允许代理对其过去的决策进行深度分析，而不是仅仅关注单一的行动。例如，在德州扑克中，Agent-Pro在每一轮结束后会反思其信念的合理性，并总结出行为准则和世界建模，以便在未来的对局中做出更为理性的选择。

在这一过程中，Agent-Pro不仅记录下对手的游戏风格，还对每个对手的行动进行分析，从而形成更加精准的信念模型。通过这种方式，它能够在复杂的博弈中不断提升自身的决策能力。

🎲 案例研究：21点与德州扑克

为了验证Agent-Pro的有效性，研究者们在21点与德州扑克这两款游戏中进行了大量实验。在这些实验中，Agent-Pro通过自我学习与反思，在与其他基线模型的对抗中表现出了显著的优势。

例如，在21点的比赛中，Agent-Pro的决策不仅更加理性，且在分析庄家手牌与自身手牌时，展现出了更强的风险评估能力。与传统的基线模型相比，Agent-Pro能够在更少的失误中，获得更高的胜率。

同样，在德州扑克的实验中，Agent-Pro通过对手的行为进行分析，能够在适当的时候虚张声势，施压对手，最终赢得比赛。这种能力的背后是其不断优化的信念模型和决策策略。

🔍 反思与未来展望

尽管Agent-Pro在多个实验中表现出色，但我们也必须认识到其局限性。首先，Agent-Pro的学习过程依赖于其基础模型的能力，特别是在推理与反思方面。此外，在与最先进的强化学习算法（如CFR plus）的比较中，Agent-Pro仍有提升的空间。

未来的研究可以进一步优化Agent-Pro，使其不仅在游戏场景中表现优异，还能适应更广泛的复杂任务。通过引入更多的环境动态与对手策略，Agent-Pro有望成为一个更加智能的自我学习代理，推动人工智能的进一步发展。

📚 参考文献

1. Zhang, W., et al. (2024). Agent-Pro:通过策略级反射和优化学习进化. arXiv:2402.17574.
2. Shinn, N., et al. (2023). Reflexion: an autonomous agent with dynamic memory and self-reflection. ArXiv.
3. Mnih, V., et al. (2015). Human-level control through deep reinforcement learning. Nature.
4. Wei, J., et al. (2022). Emergent abilities of large language models. CoRR.
5. Touvron, H., et al. (2023). Llama: Open and Efficient Foundation Language Models. ArXiv.

本文通过分析Agent-Pro的设计与实施，探讨了智能体在动态环境中如何通过策略级反思与优化学习进化，为构建更智能的人工智能代理提供了新的思路与方向。

引言 🌟

在自然语言处理（NLP）的发展浪潮中，增强检索生成（Retrieval-Augmented Generation，RAG）技术的出现无疑是一场革命。它通过结合大型语言模型（Large Language Models，LLMs）和外部知识库的优势，显著提升了文本生成的质量。然而，RAG的引入同时也带来了长序列生成的问题，导致计算和内存成本飙升。为了解决这一难题，研究团队提出了RAGCache，一个全新的多层动态缓存系统，旨在优化RAG的运行效率。

RAG的工作流程简单而高效。系统首先从知识数据库中检索相关文档，然后将这些文档与用户的请求结合，传递给LLM进行生成。通过这种方式，RAG不仅扩展了LLM的知识库，还提升了上下文理解能力。然而，随着外部知识的注入，生成的序列长度急剧增加，计算和内存的需求也随之上升，造成了资源的浪费和处理的瓶颈。

RAG系统的性能瓶颈 🔍

为了解RAG系统的现状，研究团队进行了系统性能特征分析。他们发现，性能的瓶颈主要集中在LLM生成步骤上。这一过程通常可以分为两个阶段：预填充（prefill）和解码（decoding）。在预填充阶段，系统需要计算输入序列的关键值张量，这一过程尤其耗时。随着输入序列的长度增加，预填充的延迟也随之增加，尤其当输入达到4000个标记时，延迟可达一秒钟。

通过对不同数据集和检索设置的分析，研究团队还发现了一些优化的机会。首先，多个请求中相同文档的重复出现，使得可以共享LLM推理的中间状态。其次，少数文档占据了大部分的检索请求，这意味着可以缓存这些频繁访问文档的中间状态，从而减少计算负担。

RAGCache的设计理念 💡

RAGCache的核心在于其知识树结构和前缀感知的替换策略。知识树将检索到的文档的中间状态组织在GPU和主机内存的层次结构中，频繁访问的文档存储在快速的GPU内存中，而较少访问的文档则存储在较慢的主机内存中。RAGCache采用了一种名为前缀感知贪婪双大小频率（PGDSF）的替换策略，综合考虑文档的顺序、大小、频率和近期性，以最小化缓存未命中率。

知识树结构

知识树的设计使得RAGCache能够高效地管理和访问文档的关键值张量。每个节点对应于一个文档，路径表示请求中引用的文档序列。这种结构的优点在于可以通过前缀匹配快速定位所需的张量，确保了高效的访问速度。

动态推测流水线

RAGCache还引入了动态推测流水线的策略，旨在重叠知识检索和LLM推理的计算过程。这一策略允许系统在检索阶段就开始生成过程，以减少整体延迟。例如，在检索过程中，系统会持续更新候选文档列表，并在新的文档被发现时，立即对LLM发起生成请求。这种方式使得资源的利用率更高，并且能够有效缓解延迟问题。

实验评估 🚀

研究团队在多个数据集和代表性LLM上对RAGCache进行了评估。实验结果显示，RAGCache在“首次令牌时间”（Time to First Token，TTFT）上比集成Faiss的vLLM系统提升了4倍，而吞吐量提升了2.1倍。此外，相较于SGLang，RAGCache的TTFT降低了3.5倍，吞吐量提升了1.8倍。这些结果表明，RAGCache在提升系统效率方面有着显著的优势。

模型	TTFT提升	吞吐量提升
RAGCache vs vLLM	4x	2.1x
RAGCache vs SGLang	3.5x	1.8x

结论 🏁

RAGCache作为一款创新的多层动态缓存系统，成功解决了RAG系统中的性能瓶颈问题。通过有效地缓存检索到的文档的中间状态并共享它们，RAGCache显著提高了计算效率，降低了资源消耗。随着NLP技术的不断发展，RAGCache无疑将为未来的智能文本生成应用提供强有力的支持。

参考文献

1. RAG: Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
2. vLLM: A High-Performance LLM Serving System
3. Faiss: A Library for Efficient Similarity Search
4. SGLang: Efficient Language Model Serving
5. Recent Advances in Natural Language Processing with Large Language Models

通过RAGCache的实践，研究人员开辟了一条新的道路，使得增强检索生成技术能够在高效性与计算资源之间找到最佳平衡，为未来的NLP应用打下坚实的基础。

在当今的自然语言处理领域，检索增强生成（RAG）是一个引人注目的方法，它允许大语言模型（LLMs）利用来自大型知识库的丰富信息，通过查询知识存储来寻找相关段落和内容，从而生成经过深思熟虑的响应。RAG的魅力在于它能够动态利用实时知识，即使在某些主题上并未经过专门训练的情况下，也能提供有深度的回答。

但RAG的复杂性也随之而来，尤其是在构建精细的RAG管道时。为了解决这些复杂性，我们可以借助DSPy，它提供了一种无缝的方式来设置提示管道。

配置语言模型（LM）和检索模型（RM） ⚙️

首先，我们需要设置语言模型（LM）和检索模型（RM），而DSPy通过多种LM和RM API以及本地模型托管来支持这一过程。

在本教程中，我们将使用GPT-3.5（gpt-3.5-turbo）和ColBERTv2检索器（一个免费服务器，托管了一个包含2017年维基百科“摘要”搜索索引的数据库，该数据库包含每篇文章的第一段内容）。我们将在DSPy中配置LM和RM，从而使DSPy能够在需要生成或检索时内部调用相应的模块。

import dspy

turbo = dspy.OpenAI(model='gpt-3.5-turbo')
colbertv2_wiki17_abstracts = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')

dspy.settings.configure(lm=turbo, rm=colbertv2_wiki17_abstracts)

加载数据集 📚

本教程中，我们使用HotPotQA数据集，这是一个复杂的问题-答案对集合，通常以多跳的方式进行回答。我们可以通过HotPotQA类加载这个由DSPy提供的数据集：

from dspy.datasets import HotPotQA

# 加载数据集。
dataset = HotPotQA(train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0)

# 告诉DSPy将“问题”字段视为输入。其他字段是标签和/或元数据。
trainset = [x.with_inputs('question') for x in dataset.train]
devset = [x.with_inputs('question') for x in dataset.dev]

len(trainset), len(devset)

输出:

(20, 50)

构建签名 ✍️

在加载完数据后，我们现在可以开始定义RAG管道的子任务的签名。

我们可以识别简单的输入question和输出answer，但由于我们正在构建RAG管道，我们希望利用来自ColBERT语料库的一些上下文信息。因此，让我们定义我们的签名：context, question --> answer。

class GenerateAnswer(dspy.Signature):
    """回答短小的事实性问题。"""

    context = dspy.InputField(desc="可能包含相关事实")
    question = dspy.InputField()
    answer = dspy.OutputField(desc="通常在1到5个单词之间")

我们为context和answer字段添加了小描述，以定义模型将接收和应该生成的内容的更强指引。

构建管道 🚀

我们将把RAG管道构建为一个DSPy模块，这将需要两个方法：

• __init__方法将简单地声明它所需的子模块：dspy.Retrieve和dspy.ChainOfThought。后者被定义为实现我们的GenerateAnswer签名。
• forward方法将描述使用我们拥有的模块回答问题的控制流：给定一个问题，我们将搜索前3个相关段落，然后将它们作为上下文提供给答案生成。

class RAG(dspy.Module):
    def __init__(self, num_passages=3):
        super().__init__()

        self.retrieve = dspy.Retrieve(k=num_passages)
        self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

    def forward(self, question):
        context = self.retrieve(question).passages
        prediction = self.generate_answer(context=context, question=question)
        return dspy.Prediction(context=context, answer=prediction.answer)

优化管道 🔧

编译RAG程序

在定义了这个程序后，让我们现在编译它。编译程序将更新存储在每个模块中的参数。在我们的设置中，这主要是通过收集和选择良好的示例以包含在提示中来实现的。

编译依赖于三件事：

1. 训练集。 我们将仅使用上面提到的20个问题-答案示例。
2. 验证指标。 我们将定义一个简单的validate_context_and_answer函数，检查预测的答案是否正确，并且检索到的上下文确实包含该答案。
3. 特定的提示器。 DSPy编译器包括许多提示器，可以优化您的程序。

from dspy.teleprompt import BootstrapFewShot

# 验证逻辑：检查预测答案是否正确。
# 同时检查检索的上下文是否确实包含该答案。
def validate_context_and_answer(example, pred, trace=None):
    answer_EM = dspy.evaluate.answer_exact_match(example, pred)
    answer_PM = dspy.evaluate.answer_passage_match(example, pred)
    return answer_EM and answer_PM

# 设置一个基本的提示器，将编译我们的RAG程序。
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

# 编译！
compiled_rag = teleprompter.compile(RAG(), trainset=trainset)

:::info
提示器： 提示器是强大的优化器，可以将任何程序进行引导，学习如何自生成并选择有效的模块提示。因此，它的名字意味着“远程提示”。

不同的提示器在优化成本与质量等方面提供了各种权衡。在上述示例中，我们使用了一个简单的默认BootstrapFewShot。

如果你喜欢类比，可以将其视为你的训练数据、损失函数和标准DNN监督学习设置中的优化器。而SGD是一个基本的优化器，还有更复杂（且更昂贵！）的优化器，如Adam或RMSProp。
:::

执行管道 🎉

现在我们已经编译了RAG程序，让我们试试它。

# 向这个简单的RAG程序询问任何问题。
my_question = "David Gregory继承了哪个城堡？"

# 获取预测。这包含`pred.context`和`pred.answer`。
pred = compiled_rag(my_question)

# 打印上下文和答案。
print(f"问题: {my_question}")
print(f"预测答案: {pred.answer}")
print(f"检索到的上下文（截断）: {[c[:200] + '...' for c in pred.context]}")

非常好。我们来检查最后的提示给LM的内容。

turbo.inspect_history(n=1)

输出:

回答短小的事实性问题。

---

问题: "At My Window"由哪位美国歌手/词曲作者发行？
答案: John Townes Van Zandt

问题: "Everything Has Changed"是哪个唱片公司发行的专辑中的一首歌？
答案: Big Machine Records
...(截断)

即使我们没有写出任何详细的示例，我们也看到DSPy能够为3-shot检索增强生成引导这个3,000个token的提示，并使用Chain-of-Thought推理在一个极其简单的程序中。

这展示了组合和学习的力量。当然，这只是由特定提示器生成的，其在每个设置中可能完美无瑕，也可能并非如此。正如您将在DSPy中看到的那样，您有一个庞大且系统化的选项空间，可以针对程序的质量和成本进行优化和验证。

您还可以轻松检查学习到的对象。

for name, parameter in compiled_rag.named_predictors():
    print(name)
    print(parameter.demos[0])
    print()

评估管道 📊

我们现在可以在开发集上评估我们的compiled_rag程序。当然，这个小集并不意味着是一个可靠的基准，但它将在说明中很有启发性。

让我们评估预测答案的准确性（精确匹配）。

from dspy.evaluate.evaluate import Evaluate

# 设置`evaluate_on_hotpotqa`函数。我们将多次使用它。
evaluate_on_hotpotqa = Evaluate(devset=devset, num_threads=1, display_progress=False, display_table=5)

# 使用`answer_exact_match`指标评估`compiled_rag`程序。
metric = dspy.evaluate.answer_exact_match
evaluate_on_hotpotqa(compiled_rag, metric=metric)

输出:

平均指标: 22 / 50  (44.0): 100%|██████████| 50/50 [00:00<00:00, 116.45it/s]
平均指标: 22 / 50  (44.0%)

44.0

评估检索 🔍

评估检索的准确性也可能是有启发性的。虽然有多种方式可以做到这一点，但我们可以简单地检查检索的段落是否包含答案。

我们可以利用我们的开发集，其中包括应检索的金标题。

def gold_passages_retrieved(example, pred, trace=None):
    gold_titles = set(map(dspy.evaluate.normalize_text, example['gold_titles']))
    found_titles = set(map(dspy.evaluate.normalize_text, [c.split(' | ')[0] for c in pred.context]))

    return gold_titles.issubset(found_titles)

compiled_rag_retrieval_score = evaluate_on_hotpotqa(compiled_rag, metric=gold_passages_retrieved)

输出:

平均指标: 13 / 50  (26.0): 100%|██████████| 50/50 [00:00<00:00, 671.76it/s]平均指标: 13 / 50  (26.0%)

尽管这个简单的compiled_rag程序能够正确回答相当一部分问题（在这个小集上，超过40%），但检索的质量则低得多。

这可能表明LM在回答问题时往往依赖于它在训练期间记住的知识。为了应对这种较弱的检索，我们将探索一个涉及更高级搜索行为的第二个程序。

---

通过这个详细的示例，我们可以看到如何利用DSPy构建一个RAG管道，配置和优化我们的模型，并评估其性能。这不仅展示了DSPy的强大能力，也为使用RAG技术提供了清晰的方向。