博客

In the rapidly evolving landscape of artificial intelligence, Large Language Models (LLMs) have become indispensable tools, offering unparalleled capabilities in understanding and generating human-like text. Traditionally, these models have been deployed in data centers equipped with powerful GPUs, but there’s a growing trend to bring these capabilities to more ubiquitous devices like smartphones. This shift aims to leverage rich personal data while maintaining privacy by keeping computations local. However, deploying LLMs on smartphones presents significant challenges due to their limited processing power and memory. Enter PowerInfer-2, a groundbreaking framework from the Institute of Parallel and Distributed Systems (IPADS) at Shanghai Jiao Tong University, designed to tackle these challenges head-on.

Introduction to PowerInfer-2

PowerInfer-2 is an innovative framework specifically engineered for high-speed inference of LLMs on smartphones, even for models whose sizes exceed the device’s memory capacity. The key to PowerInfer-2’s success lies in its ability to utilize the heterogeneous computation, memory, and I/O resources available in modern smartphones. By decomposing traditional matrix computations into fine-grained neuron cluster computations, PowerInfer-2 significantly enhances inference speed and efficiency.

Key Features of PowerInfer-2

1. Polymorphic Neuron Engine: Adapts computational strategies for various stages of LLM inference.
2. Segmented Neuron Caching: Minimizes and conceals I/O overhead.
3. Fine-Grained Neuron-Cluster-Level Pipelining: Reduces computational delays caused by I/O operations.
4. Support for Large Models: Capable of running models with up to 47 billion parameters.

Technical Insights

Heterogeneous Computation Utilization

PowerInfer-2 leverages the heterogeneous hardware present in smartphones, such as asymmetric big.LITTLE CPU cores, GPUs, and NPUs. This approach allows the framework to dynamically adapt to the strengths of each component during the different stages of LLM inference.

Prefill Stage

During the prefill stage, which processes all tokens in the input sequence concurrently, PowerInfer-2 employs the NPU to handle large matrix computations. This stage benefits from the NPU’s efficiency in processing dense computations, significantly speeding up the generation of the first token.

Decoding Stage

In the decoding stage, where tokens are generated sequentially, PowerInfer-2 utilizes small neuron clusters and CPU cores to handle the sparse computations. This method leverages the flexibility of CPU cores, which are well-suited for the lighter computational tasks associated with sparse activations.

Neuron Caching and Pipelining

PowerInfer-2 introduces a segmented cache that operates at the neuron granularity level. This cache is designed to enhance the cache hit rate and reduce the impact of I/O overhead on inference performance. By overlapping I/O operations with neuron cluster computations, the framework minimizes waiting times and maximizes throughput.

Offline Planner

Before running a new model on a smartphone, PowerInfer-2 executes an offline planning phase. This phase analyzes the model and hardware specifications to generate an execution plan that optimally configures computation, memory, and I/O resources. This plan ensures that inference is performed efficiently, even for models that do not fit entirely in memory.

Implementation and Evaluation

PowerInfer-2 has been implemented with an additional 12,000 lines of code on top of the original PowerInfer framework. The researchers deployed it on two smartphones: OnePlus 12 and Ace 2, equipped with Qualcomm XPUs and 24GB and 16GB of DRAM, respectively.

Supported Models

PowerInfer-2 supports a diverse array of LLMs, including:

• Llama-2 (7B, 13B)
• TurboSparse-Mistral (7B)
• TurboSparse-Mixtral (47B)

Performance

The evaluation of PowerInfer-2 shows impressive results:

• Speed: Up to 29.2× speed increase compared to state-of-the-art frameworks.
• Memory Efficiency: Approximately 40% reduction in memory usage for smaller models while maintaining comparable inference speeds.

Notably, PowerInfer-2 is the first system to support the TurboSparse-Mixtral-47B model on mobile platforms, achieving a generation speed of 11.68 tokens per second.

Real-World Applications

To demonstrate its practical utility, PowerInfer-2 was tested on various real-world tasks such as multi-turn dialogue, code generation, math problem solving, and role play. The framework consistently delivered high performance across these diverse tasks, showcasing its robustness and versatility.

Conclusion

PowerInfer-2 represents a significant advancement in the deployment of LLMs on smartphones. By harnessing the heterogeneous resources of modern smartphones and optimizing computation, memory, and I/O operations, PowerInfer-2 enables high-speed, efficient inference for even the largest models. This innovation opens up new possibilities for privacy-preserving, intelligent personal assistants and other applications that require powerful language understanding and generation capabilities on mobile devices.

For more details and a demonstration video, visit the PowerInfer-2 project site.

近年来，深度学习领域涌现出许多令人惊叹的应用，而这些应用背后的核心力量往往是基于Transformer架构及其核心注意力机制的“基础模型”。为了解决Transformer在处理长序列时计算效率低下的问题，许多次二次时间复杂度的架构被开发出来，例如线性注意力、门控卷积、循环模型和结构化状态空间模型（SSMs）。然而，这些模型在语言等重要模态上的表现却不如注意力机制出色。

本文将深入探讨这些模型的局限性，并提出一种全新的选择性状态空间模型，它在多个方面超越了先前工作，在保持线性时间复杂度的同时，实现了与Transformer相当的建模能力。

Transformer的局限性：效率与效果的权衡

Transformer凭借其强大的自注意力机制，能够在上下文窗口内密集地传递信息，从而对复杂数据进行建模。然而，这种机制也带来了两个关键问题：

1. 有限的上下文窗口: Transformer无法处理超过窗口大小的任何信息。
2. 二次复杂度: 随着窗口大小的增加，Transformer的计算量呈平方增长。

为了克服这些问题，研究人员一直在探索更有效的注意力机制变体，但往往以牺牲注意力机制的有效性为代价。至今，还没有一种变体能够在多个领域中展现出大规模的有效性。

结构化状态空间模型（SSMs）：线性时间复杂度的希望

近年来，结构化状态空间序列模型（SSMs）作为一种很有潜力的序列建模架构，逐渐崭露头角。这些模型可以被看作是循环神经网络（RNNs）和卷积神经网络（CNNs）的结合，并受到了经典状态空间模型（Kalman 1960）的启发。SSMs可以高效地以循环或卷积的形式进行计算，其时间复杂度和空间复杂度都与序列长度呈线性或近线性关系。此外，它们还拥有建模某些数据模态中长程依赖关系的机制，并在Long Range Arena（Tay, Dehghani, Abnar, et al. 2021）等基准测试中取得了领先地位。

然而，SSMs在建模离散和信息密集型数据（如文本）方面表现不佳。

选择性状态空间模型：突破SSMs的局限

本文提出的选择性状态空间模型，通过以下几个方面的改进，克服了先前工作的局限性，实现了与Transformer相当的建模能力，并保持了线性时间复杂度：

选择机制：基于内容的推理

先前模型的一个关键局限性在于它们无法以输入依赖的方式高效地选择数据（例如，关注或忽略特定输入）。受选择性复制和归纳头等重要合成任务的启发，本文设计了一种简单的选择机制，通过将SSM参数设置为输入的函数，从而使模型能够根据当前标记有选择地传播或遗忘信息。

硬件感知算法：高效的并行计算

这种简单的改变为模型的计算带来了技术挑战，因为先前所有的SSM模型都必须是时间和输入不变的，才能保证计算效率。本文通过一种硬件感知算法克服了这一挑战，该算法以扫描而不是卷积的方式递归地计算模型，但不会将扩展后的状态具体化，从而避免了GPU内存层次结构不同级别之间的IO访问。这种实现方法在理论上比以前的方法更快（时间复杂度为线性，而所有基于卷积的SSMs的时间复杂度为伪线性），并且在现代硬件上也更快（在A100 GPU上快3倍）。

Mamba架构：简洁而强大的模型设计

本文将先前SSM架构（Dao, Fu, Saab, et al. 2023）的设计与Transformer的MLP块结合，形成一个简单的同质架构设计（Mamba），该架构包含选择性状态空间。

Mamba作为一种通用的序列模型主干，具有以下特点：

• 高性能: 选择机制在语言和基因组等密集模态上带来了强大的性能。
• 快速训练和推理: 训练过程中的计算量和内存使用量与序列长度呈线性关系，而推理过程中的自回归展开仅需要每个步骤恒定的时间，因为不需要缓存先前元素。
• 长上下文: 性能和效率的结合，使模型能够在长达百万个标记的真实数据上取得性能提升。

Mamba的实验验证：超越Transformer的性能

本文通过一系列实验验证了Mamba作为通用序列基础模型主干的潜力，包括在预训练质量和特定领域任务性能方面的评估。

合成任务：选择性复制和归纳头

在选择性复制任务中，Mamba展现出强大的内容感知推理能力，能够有效地记住相关标记，并忽略无关标记。在归纳头任务中，Mamba能够完美地解决该任务，并将其解决方案扩展到百万个标记的序列长度，而其他方法只能扩展到训练序列长度的两倍。

语言建模：与Transformer相当的性能

在语言建模方面，Mamba是第一个真正实现Transformer级性能的线性时间序列模型，无论是在预训练困惑度还是在零样本评估方面。在高达10亿个参数的规模下，Mamba的性能超越了各种基线，包括基于LLaMa（Touvron et al. 2023）的现代Transformer训练方案。Mamba语言模型的生成吞吐量是同等规模Transformer的5倍，Mamba-3B的质量与Transformer的两倍规模（例如，Pythia-7B）相当，甚至在常识推理方面超过了Pythia-7B。

DNA建模：高效的基因组分析

在基因组分析方面，Mamba在DNA序列预训练和微调方面都超越了先前最先进的模型，例如SaShiMi、Hyen和Transformer。在预训练质量和下游指标（例如，将具有挑战性的语音生成数据集上的FID降低一半以上）方面，Mamba都取得了优异的成绩。在两种情况下，Mamba的性能都随着上下文长度的增加而提升，直至百万个标记的序列长度。

音频建模：高质量的语音生成

在音频建模方面，Mamba在自回归音频建模方面超越了先前最先进的模型（SaShiMi），并能够处理长达分钟的上下文或百万个标记的序列（控制计算量）。在SC09语音生成数据集上，Mamba模型在保真度指标方面显著优于现有模型，包括WaveNet、SampleRNN、WaveGAN、DiffWave和SaShiMi。

Mamba的效率：超越Transformer的计算速度

Mamba在训练和推理方面都展现出优异的效率。在训练方面，Mamba的效率扫描比PyTorch中的标准扫描实现快20-40倍。在推理方面，Mamba的推理吞吐量是同等规模Transformer的4-5倍，因为Mamba不需要KV缓存，因此可以采用更高的批次大小。

Mamba的未来展望：更强大的基础模型

本文提出的选择性状态空间模型为构建不同领域的基础模型开辟了新的可能性，尤其是在需要长上下文的领域，例如基因组学、音频和视频。Mamba有望成为一种通用的序列模型主干，为未来的深度学习研究带来新的突破。

参考文献

• Brown, Tom, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, et al. “Language Models Are Few-Shot Learners.” arXiv preprint arXiv:2005.14165, 2020.
• Vaswani, Ashish, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. “Attention Is All You Need.” In Advances in Neural Information Processing Systems, 5998–6008, 2017.
• Gu, Albert, Karan Goel, and Christopher Ré. “Efficiently Modeling Long Sequences with Structured State Spaces.” In International Conference on Learning Representations, 2022.
• Dao, Tri, Daniel Y Fu, Andrew M Saab, et al. “H3: A Unified Architecture for Long Sequence Modeling.” In International Conference on Learning Representations, 2023.
• Poli, Luca, Thomas Scialom, Guillaume Lample, et al. “Hyena: A Hybrid Convolutional Architecture for Long Sequence Modeling.” In International Conference on Learning Representations, 2023.

---

Q: 这篇论文试图解决什么问题？

A: 这篇论文试图解决的问题是深度学习中基础模型（Foundation Models, FMs）在处理长序列数据时的计算效率问题。基础模型通常基于Transformer架构，尽管它们在多种领域（如语言、图像、语音、音频、时间序列和基因组学）的应用中表现出色，但它们的计算复杂度随着序列长度的增加而呈二次方增长，这限制了它们在处理长序列数据时的应用。为了克服这一挑战，论文提出了一种新的序列建模方法，称为选择性状态空间模型（Selective State Space Models, SSMs），并将其集成到一个简化的神经网络架构中，称为Mamba。Mamba旨在实现线性时间复杂度的序列建模，同时保持或超越Transformer模型在多种模态（如语言、音频和基因组学）上的性能。

Q: 有哪些相关研究？

A: 这篇论文提到了多个与选择性状态空间模型（Selective State Space Models, SSMs）和Mamba架构相关的研究。以下是一些关键的相关研究：

1. Transformer架构：这是由Vaswani等人在2017年提出的，它的核心是自注意力机制，能够处理长距离依赖关系，但计算复杂度随序列长度的增加而增加。
2. 结构化状态空间序列模型（Structured State Space Models, SSMs）：这些模型是RNN和CNN的结合，能够高效地处理序列数据，具有线性或近线性的序列长度缩放特性。Gu, Goel, and Ré (2022) 和 Gu, Johnson, Goel, et al. (2021) 在这方面的工作为Mamba架构提供了理论基础。
3. 线性注意力（Linear Attention）：Katharopoulos等人在2020年提出了一种近似自注意力的方法，通过递归来实现，这为后续的SSM研究提供了灵感。
4. H3架构：Dao, Fu, Saab等人在2023年提出了这种架构，它结合了线性注意力和SSM，通过门控连接来增强模型的性能。
5. Hyena模型：Poli等人在2023年提出了这种模型，它使用全局卷积来近似SSM，并且在某些连续信号数据领域（如音频和视觉）取得了成功。
6. RetNet：Sun等人在2023年提出了这种模型，它通过引入额外的门控来优化SSM的并行计算路径。
7. RWKV（Reinventing RNNs for the Transformer Era）：Peng等人在2023年提出了这种模型，它基于线性注意力近似，旨在为语言建模设计高效的RNN。
8. S5模型：Smith, Warrington, and Linderman在2023年提出了这种模型，它通过简化SSM架构来提高计算效率。

这些研究为Mamba架构的发展提供了理论基础和实践经验，特别是在处理长序列数据和提高计算效率方面。

Q: 论文如何解决这个问题？

A: 论文通过以下几个关键创新来解决长序列数据处理中的计算效率问题：

1. 选择性状态空间模型（Selective State Space Models, SSMs）：论文提出了一种新的SSM，它通过允许模型参数（如状态转移矩阵A、输入门B和输出门C）依赖于输入数据，从而实现对信息的选择性传播或遗忘。这种机制使得模型能够根据当前输入动态地调整其状态，有效地过滤掉不相关的信息。
2. 硬件感知的并行算法：尽管选择性SSMs的设计破坏了模型的线性时间不变性（LTI），但论文设计了一种硬件感知的并行算法，通过在GPU内存层次结构中更高效地扩展状态来计算模型。这种算法通过在快速SRAM中执行离散化和递归操作，然后仅将最终输出写回HBM，从而减少了内存访问次数，提高了计算效率。
3. 简化的神经网络架构（Mamba）：论文提出了一个简化的端到端神经网络架构，该架构不包含注意力或多层感知器（MLP）块，而是将SSMs直接集成到网络中。这种架构通过合并H3架构中的线性注意力和MLP块，形成了一个简单且同质的架构设计。
4. 跨模态性能验证：论文在多种模态（如语言、音频和基因组学）上验证了Mamba架构的有效性。在语言建模任务中，Mamba-3B模型在预训练和下游评估中的表现超过了相同大小的Transformer模型，并与两倍大小的Transformer模型相匹配。

通过这些创新，论文展示了Mamba架构在处理长序列数据时的高效性和优越性能，特别是在保持或提高模型性能的同时，实现了线性时间复杂度的序列建模。

Q: 论文做了哪些实验？

A: 论文进行了一系列的实验来验证Mamba架构的有效性，这些实验涵盖了不同的数据模态和任务。以下是主要的实验内容：

1. 合成任务：
   • 选择性复制（Selective Copying）：测试模型在处理随机间隔的输入序列时的记忆能力，这要求模型能够记住相关输入并忽略不相关的“噪声”输入。
   • 归纳头（Induction Heads）：评估模型在关联记忆任务中的表现，这要求模型能够在给定上下文的情况下正确地预测输出。
2. 语言建模：
   • 预训练质量（Scaling Laws）：在Pile数据集上，比较Mamba与其他架构（如Transformer、Transformer++、H3等）在不同模型大小和序列长度下的困惑度（Perplexity）。
   • 零样本下游评估（Zero-shot Evaluations）：在多个下游任务上评估Mamba模型的性能，包括LAMBADA、HellaSwag、PIQA、ARC-challenge等。
3. DNA序列建模：
   • 模型规模（Scaling: Model Size）：在HG38（人类基因组）数据集上，研究不同模型背骨在不同规模下的性能。
   • 上下文长度（Scaling: Context Length）：固定模型规模，增加序列长度，观察模型性能随序列长度的增长情况。
   • 合成物种分类（Synthetic Species Classification）：在预训练模型的基础上，进行物种DNA序列的分类任务，以评估模型在长序列上的泛化能力。
4. 音频建模和生成：
   • 长上下文自回归预训练（Long-Context Autoregressive Pretraining）：在YouTubeMix数据集上，评估Mamba在不同序列长度下的预训练质量。
   • 自回归语音生成（Autoregressive Speech Generation）：在SC09数据集上，比较Mamba模型与现有最先进模型在自动语音生成任务上的性能。
5. 速度和内存基准测试（Speed and Memory Benchmarks）：
   • SSM扫描操作（Scan Operation）：在A100 GPU上，比较Mamba的SSM扫描操作与标准卷积和注意力操作的速度。
   • 端到端推理吞吐量（End-to-end Inference Throughput）：测量Mamba模型在不同批处理大小下的推理速度。
   • 内存消耗（Memory Consumption）：报告Mamba模型在训练过程中的内存使用情况，并与优化的Transformer模型进行比较。

这些实验旨在全面评估Mamba架构在不同场景下的性能，包括其在处理长序列数据时的效率和效果。

Q: 有什么可以进一步探索的点？

A: 尽管论文提出了Mamba架构并在多个领域展示了其有效性，但仍有一些潜在的研究方向可以进一步探索：

1. 模型规模的扩展：论文中的实验主要集中在较小的模型规模上。研究Mamba在更大模型规模（例如数十亿参数）上的性能，以及它是否能够保持或提高其在长序列任务上的优势。
2. 多模态学习：探索Mamba在处理多模态数据（如结合文本、图像和音频）时的性能，以及如何有效地整合不同模态的信息。
3. 跨领域迁移学习：研究Mamba在不同领域（如医疗、金融、法律等）的迁移学习能力，以及如何调整模型以适应特定领域的知识。
4. 模型解释性：提高Mamba模型的可解释性，以便更好地理解其在处理复杂任务时的决策过程。
5. 计算效率的进一步优化：尽管Mamba在计算效率上有所改进，但仍然可以探索新的算法和硬件优化技术，以进一步提高其在大规模部署中的实用性。
6. 长期记忆和上下文建模：研究Mamba在处理需要长期记忆和复杂上下文理解的任务（如故事生成、对话系统等）中的性能。
7. 模型鲁棒性：评估Mamba在面对噪声、异常值和对抗性攻击时的鲁棒性，并探索提高模型鲁棒性的策略。
8. 环境交互和强化学习：将Mamba应用于需要与环境交互的任务，如强化学习中的决策制定，以及探索其在这些任务中的性能和适用性。
9. 模型压缩和部署：研究如何有效地压缩Mamba模型以便于在资源受限的设备上部署，同时保持其性能。
10. 社会影响和伦理考量：随着模型规模的扩大，研究Mamba在实际应用中可能产生的社会影响，以及如何确保其符合伦理和公平性标准。

这些研究方向不仅有助于推动Mamba架构的发展，还能够为深度学习和人工智能领域的其他研究提供新的视角和方法。

Q: 总结一下论文的主要内容

A: 这篇论文介绍了一种名为Mamba的新型线性时间序列建模架构，旨在提高深度学习中基础模型（Foundation Models, FMs）在处理长序列数据时的计算效率。Mamba的核心是选择性状态空间模型（Selective State Space Models, SSMs），这些模型通过引入选择机制来改进传统的结构化状态空间模型（Structured State Space Models, SSMs），使其能够根据输入内容动态地选择性地处理信息。这种选择性允许模型在保持线性时间复杂度的同时，有效地处理长序列数据。

论文的主要贡献包括：

1. 选择性SSMs：提出了一种新的SSM，通过让模型参数依赖于输入，实现了对信息的选择性传播和遗忘，从而提高了模型在处理离散和信息密集型数据（如文本）时的性能。
2. 硬件感知的并行算法：设计了一种新的并行计算方法，通过在GPU内存层次结构中更高效地处理状态扩展，解决了选择性SSMs的计算效率问题。
3. 简化的神经网络架构：提出了Mamba架构，它将SSMs与Transformer的MLP块结合，形成了一个简单且同质的网络设计，无需额外的注意力或MLP块。
4. 跨模态性能验证：在多种数据模态（如语言、音频和基因组学）上验证了Mamba架构的有效性，展示了其在预训练质量和下游任务性能上的优势。
5. 效率基准测试：展示了Mamba在训练和推理速度上的优势，特别是在处理长序列数据时，其性能优于现有的Transformer模型。

论文的实验结果表明，Mamba在处理长序列数据时不仅提高了计算效率，而且在多个领域内实现了与Transformer模型相媲美或更优的性能。这表明Mamba有潜力成为通用序列模型的有力候选者，特别是在需要处理长序列数据的新兴领域，如基因组学、音频和视频。

近年来，深度学习领域涌现出许多新的模型架构，其中状态空间模型（SSM，State Space Model）因其优雅的数学性质和强大的表达能力，逐渐成为Transformer的强劲对手。而Mamba，作为SSM最新的变体，更是凭借其在长序列建模上的优异表现，吸引了众多研究者的关注。

本文将带您深入了解SSM的核心概念，并重温其重要奠基之作——HiPPO（High-order Polynomial Projection Operators）。通过HiPPO的推导，您可以理解线性系统在SSM中的重要性，以及它如何通过有限维的向量来储存无限维的函数信息。

线性系统：简单而强大的表达能力

SSM的核心思想是利用线性微分方程（ODE）系统来建模序列数据。一个典型的线性 ODE 系统可以表示为：

$$
\frac{dh}{dt} = Ah + Bu
$$

其中，$h$ 代表系统的状态，$u$ 代表输入，$A$ 和 $B$ 是模型参数。

那么，为什么SSM会选择线性系统呢？答案是：线性系统既足够简单，也足够复杂。

简单是指，线性化通常是复杂系统的一个最基本近似。而复杂是指，即使是如此简单的系统，也可以拟合异常复杂的函数。例如，一个简单的线性系统：

$$
\frac{dh}{dt} = h
$$

其解为 $h(t) = h(0)e^t$。这意味着，只要时间足够长，该线性系统就可以通过指数函数来拟合足够复杂的函数。

HiPPO：从正交基逼近到线性系统

HiPPO 为我们提供了一种更本质的理解：当我们试图用正交基去逼近一个动态更新的函数时，其结果就是如上的线性系统。

假设我们要用一个有限维的向量来储存一段信号 $x(t)$ 的信息。如果我们假设 $x(t)$ 在某点 $t_0$ 阶可导，那么它对应的 $t_0$ 阶泰勒展开式往往是 $x(t)$ 的良好近似。我们可以只储存展开式的系数，从而将 $x(t)$ 压缩为一个有限维向量。

然而，实际遇到的数据通常无法满足“阶可导”这种苛刻的条件。因此，我们更倾向于使用正交函数基展开，比如傅里叶级数。其系数计算公式为：

$$
c_k = \int_{-\infty}^{\infty} x(t)e^{-2\pi ikt} dt
$$

通过只保留有限个系数，我们可以将 $x(t)$ 压缩为一个有限维向量。

接下来，问题难度升级。实际中，$x(t)$ 代表的是持续采集的信号，所以它是不断有新数据进入的。我们需要更新逼近结果来记忆整个信号的历史。

为了解决这个问题，我们可以将 $x(t)$ 映射到一个有限区间 $[0, T]$，然后计算其在该区间上的傅里叶系数。

$$
c_k(T) = \int_{0}^{T} x(t)e^{-2\pi ikt} dt
$$

当新的数据进入时，我们可以重新计算系数，从而更新对 $x(t)$ 的逼近。

通过对系数的导数进行推导，我们可以发现，系数的变化满足一个线性 ODE 系统。这意味着，当我们试图用傅里叶级数去记忆一个实时函数的最邻近窗口内的状态时，结果自然而言地导致了一个线性 ODE 系统。

HiPPO 矩阵：勒让德多项式的应用

HiPPO 的核心是选取多项式为基函数。其中，勒让德多项式因其在实数空间中的定义和简化推导过程的优势，成为了 HiPPO 的首选。

勒让德多项式 $P_n(x)$ 是关于 $x$ 的 $n$ 次函数，定义域为 $[-1, 1]$，满足：

$$
\int_{-1}^{1} P_m(x)P_n(x) dx = \frac{2}{2n + 1}\delta_{mn}
$$

通过将勒让德多项式作为基函数，并利用其递归公式，我们可以推导出一个恒等式：

$$
\frac{d}{dT}P_n(2T/T – 1) = \frac{2n}{T}P_{n-1}(2T/T – 1)
$$

利用该恒等式，我们可以得到 HiPPO 矩阵，它描述了系数随时间的变化规律。

HiPPO 的应用：SSM 的基石

HiPPO 的结论被后来诸多 SSM 模型所使用，例如 S4 和 Mamba。HiPPO 为我们提供了一种理解 SSM 的全新视角，它揭示了线性系统在 SSM 中的本质意义，以及它如何通过有限维的向量来储存无限维的函数信息。

总结

本文以尽可能简单的方式重复了 HiPPO 的主要推导。HiPPO 通过适当的记忆假设，自下而上地导出了线性 ODE 系统，并针对勒让德多项式的情形求出了相应的解析解（HiPPO 矩阵）。其结果被后来诸多 SSM 模型使用，可谓是 SSM 的重要奠基之作。

参考文献

[1] https://papers.cool/arxiv/2312.00752
[2] https://papers.cool/arxiv/2305.13048
[3] https://papers.cool/arxiv/2307.08621
[4] https://papers.cool/arxiv/2008.07669
[5] https://dblp.org/pid/130/0612.html
[6] https://en.wikipedia.org/wiki/Kronecker_delta
[7] https://en.wikipedia.org/wiki/Legendre_polynomials
[8] https://en.wikipedia.org/wiki/Gram–Schmidt_process
[9] https://en.wikipedia.org/wiki/Chebyshev_polynomials
[10] https://en.wikipedia.org/wiki/Laguerre_polynomials
[11] https://proceedings.neurips.cc/paper/2019/file/952285b9b7e7a1be5aa7849f32ffff05-Paper.pdf

近年来，大型语言模型（LLM）在理解和执行自然语言指令方面展现出惊人的能力，为自然语言处理领域带来了革命性的变革。然而，LLM 并不总是能准确地响应包含特定约束的指令。例如，要求 LLM 生成特定长度的文章摘要或带有特定情感的电子邮件，它们可能无法满足这些要求。因此，评估 LLM 对包含特定约束指令的响应能力至关重要。

可控文本生成：传统方法的局限性

可控文本生成（CTG）是指在生成文本时满足特定约束条件的过程。传统 CTG 研究主要集中在离散变量的控制条件上，例如控制文本长度或包含特定关键词。然而，这种方法并不适用于新的指令遵循范式，因为后者需要使用自然语言指令来表达约束条件。这种差异使得传统 CTG 的评估方法无法直接应用于 LLM 或相关应用。

此外，在现实场景中，指令中的约束条件通常以自由形式的自然语言表达，例如“写一篇关于人工智能的简短文章”。因此，LLM 需要能够理解各种表达方式的约束条件，并生成符合要求的文本。简单地将传统 CTG 任务中的有限约束条件转换为固定模板的自然语言指令并不能满足这一需求。缺乏指令的多样性会阻碍评估 LLM 在泛化场景下的可控文本生成能力，以及与实际用户期望的匹配程度。

CoDI-Eval：一个新的基准测试

为了填补这一空白，并推动 LLM 与人类期望更好地对齐的研究，我们提出了 CoDI-Eval（Controllable Generation under Diversified Instructions），一个新的基准测试，用于系统地评估 LLM 的可控生成能力。CoDI-Eval 涵盖了各种 CTG 任务，并使用多样化的自然语言指令来表达约束条件，从而更准确地衡量 LLM 对包含特定约束指令的响应能力。

CoDI-Eval 在覆盖范围和泛化能力方面都具有优势。在覆盖范围方面，我们选择了五个典型的 CTG 任务，涵盖了情感、主题、长度、关键词和避免毒性等方面。此外，我们还包含了一个多方面控制的任务，同时包含两个方面的约束条件，以测试 LLM 在更具挑战性的复杂场景下的表现。

在泛化能力方面，我们通过两步流程最大限度地提高了指令的多样性。第一步是“扩展”，使用一个强大的 LLM 生成更多指令，从而构建指令池。第二步是“多样化”，通过对指令进行文本重写，以不同的方式表达相同的约束条件。我们使用 Bootstrap 方法重复第二步，直到达到预期的指令规模。这两个步骤都由 LLM 自动完成，无需人工干预。

CoDI-Eval 的评估方法

为了评估 CoDI-Eval，我们为每个 CTG 任务收集或构建了自动化、易于使用且可靠的评估方法。对于无法直接评估的任务，我们借助现有的开源专用模型或外部 API，并证明这些替代方法与人工评估结果一致。每个 CTG 任务的评估指标是准确率，我们使用所有 CTG 任务的平均准确率来衡量不同 LLM 的可控生成能力。

实验结果

我们对主流 LLM（例如 ChatGPT、LLaMA2-chat、Vicuna）进行了广泛的评估，结果表明，顶级商业 LLM 在所有 CTG 任务上都取得了最高得分，而我们测试的开源 LLM 在准确率上存在超过 10% 的差距。此外，经过微调的 LLM 表现优于基础语言模型，而那些在更大规模数据上进行微调的模型（例如 LLaMA2-chat、ChatGLM）也比仅经过指令微调的同参数量 LLM（例如 Vicuna、Alpaca）表现更好。

在不同任务上的表现方面，LLM 在情感和主题控制任务上表现相对较好。然而，当这两个属性组合在一起时，任务难度会增加，所有 LLM 的准确率都未达到 80%。我们以 GPT-3.5-turbo 为例，分析了 LLM 在多方面可控生成任务上出现错误的原因。

在避免毒性任务中，只有经过对齐微调的 LLM（例如 RLHF）才能在这项任务上表现良好，特别是经过更精细对齐训练的 GPT-4 和 GPT-3.5-turbo。

在硬约束方面，LLM 在关键词任务上的准确率接近平均准确率。我们分析了 LLM 在复杂关键词 CTG 任务上出现错误的原因。然而，在看似简单的长度 CTG 任务中，即使是 GPT-3.5-turbo 的准确率也只有 55%，这表明大多数 LLM 对长度的感知能力不足。然而，GPT-4 在这项任务上表现出更强的能力。我们计算了 GPT-3.5-turbo 在长度控制生成每个子任务上的准确率，发现准确率与目标长度范围大致呈正相关。

结论

本文介绍了 CoDI-Eval，一个用于评估 LLM 可控文本生成能力的新基准测试。我们的基准测试包含一组评估指令，涉及多个 CTG 任务，并使用各种自然语言表达方式来表达约束条件。我们的结果表明，经过指令微调的 LLM 能够执行某些 CTG 任务，但生成文本的准确率还有待提高，特别是对于某些特定的约束条件。我们还观察到开源 LLM 与闭源商业 LLM 之间的性能差距，这为未来的研究指明了方向。

参考文献

• Chen, Yihan, et al. “Benchmarking Large Language Models on Controllable Generation under Diversified Instructions.” Proceedings of the AAAI Conference on Artificial Intelligence, vol. 38, no. 1, 2024, pp. 17808-17816.

---

Q: 这篇论文试图解决什么问题？

A: 这篇论文试图解决的问题是：大型语言模型（LLMs）在遵循自然语言指令方面表现出色，但目前尚不清楚它们是否能够以及在多大程度上能够响应指令中可能隐含的明确约束。为了更好地评估LLMs对具有特定约束的指令的响应，论文提出了一个新的基准测试（Benchmark），名为CoDI-Eval（Controllable Generation under Diversified Instructions），用于系统和全面地评估LLMs对具有各种约束的指令的响应。

具体来说，论文的主要贡献包括：

1. 提出了一个新的基准测试CoDI-Eval，它通过纳入自然语言格式的多样化指令来评估LLMs的可控文本生成（CTG）能力，超越了传统的评估方法。
2. 伴随着基准测试，提供了自动化且易于使用的评估方法，以促进进一步的发展。
3. 对一系列已创建的LLMs进行了零样本（zero-shot）和少样本（few-shot）评估，首次系统地验证并比较了它们在CTG任务上的性能。

论文通过构建一个大型的、具有约束属性的指令集合作为测试套件，专注于泛化和覆盖范围，并通过指令多样化过程来合成不同形式的约束表达，同时仔细考虑了候选任务分类，以更细粒度的子类别进行划分。最后，论文自动化了整个评估过程，以促进未来的研究发展。

Q: 有哪些相关研究？

A: 论文中提到的相关研究主要包括以下几个方面：

1. 大型语言模型（LLMs）：研究者们开发了各种方法来增强或利用LLMs的能力，包括指令调整（instruction tuning）和上下文学习（in-context learning，ICL）。
2. 数据生成：利用LLMs生成数据的趋势，例如Self-Instruct和Unnatural Instructions，这些方法依赖于LLMs提供指令和响应，以克服手动编写数据的局限性。
3. 可控文本生成（Controllable Text Generation, CTG）：当前的CTG任务主要集中在硬约束和软约束两类上。硬约束限制文本的词汇和语法，如控制文本长度和确保生成的文本包含某些关键词。软约束旨在限制文本的语义，如情感和主题。
4. CTG的评估：之前没有统一的CTG领域基准，但一些研究尝试了不同的评估方法。例如，PPLM设计了几种短前缀作为CTG模型的输入，DExperts采用了与RealToxicPrompt类似的方法，通过构建多个提示来评估模型在不同输入提示下控制情感的能力。
5. 指令遵循：研究者们也关注了LLMs遵循指令的能力，例如通过使用分类任务中的指令来评估LLMs是否能够遵守指令中的要求。
6. 模型性能比较：论文中还提到了对不同LLMs在CoDI-Eval基准测试上的性能进行了比较，揭示了它们在遵循具有特定约束的指令方面的局限性。

这些相关研究为论文提出的CoDI-Eval基准测试提供了理论和技术背景，并且展示了LLMs在可控文本生成方面的潜力和挑战。论文通过这些研究的对比，强调了其在指令多样化和评估自动化方面的创新点。

Q: 论文如何解决这个问题？

A: 论文通过以下几个步骤解决大型语言模型（LLMs）在遵循带有特定约束的指令方面评估的问题：

1. 提出CoDI-Eval基准测试：CoDI-Eval（Controllable Generation under Diversified Instructions）是一个新提出的基准测试，旨在系统和全面地评估LLMs对带有各种约束的指令的响应能力。
2. 构建测试套件：作者构建了一个大型的、具有约束属性的指令集合作为测试套件，这些指令专注于泛化和覆盖范围，以确保能够全面评估LLMs的性能。
3. 指令多样化：通过一个两步过程来最大化指令的多样性。首先，从一个小型的、人工策划的种子指令集开始，然后通过扩展过程增加指令数量，构建指令池。其次，从池中随机抽取指令，并通过文本重写的方式进一步多样化这些指令。
4. 自动化评估过程：为了促进进一步的研究发展，作者自动化了整个评估过程，包括指令的生成、多样化以及评估方法的自动化。
5. 评估方法：对于每个可控文本生成任务，作者收集或构建了自动化、易于使用且可靠的评估方法。对于不能直接评估的任务，作者使用了开源的、专门的模型或外部API，并证明了这些替代方法与人类评估具有合格的一致性。
6. 实验验证：作者对一系列主流的LLMs（例如ChatGPT、LLaMA-13B-chat、Vicuna-13B等）进行了广泛的评估，以验证CoDI-Eval的性能，并揭示了LLMs在遵循具有特定约束的指令方面的局限性。
7. 性能比较：通过比较不同LLMs在CoDI-Eval上的性能，作者揭示了开源LLMs与商业闭源LLMs之间的性能差距，并指出了未来研究的潜在方向。

通过这些步骤，论文不仅提出了一个新的基准测试来评估LLMs的可控文本生成能力，而且还通过实验验证了该基准测试的有效性，并为未来的研究提供了一个有用的工具。

Q: 论文做了哪些实验？

A: 论文中进行了以下实验来验证CoDI-Eval基准测试的有效性和评估不同大型语言模型（LLMs）的性能：

1. 模型性能评估：作者对一系列主流的LLMs进行了评估，包括商业模型（如GPT-4和ChatGPT）和开源模型（如LLaMA-13B-chat、Vicuna-13B等）。评估的目的是验证这些模型在遵循带有特定约束的指令方面的能力。
2. 零样本（Zero-shot）和少样本（Few-shot）设置：作者使用了零样本和少样本的提示来测试LLMs对指令中约束的响应能力。零样本设置没有使用任何示例，而少样本设置则在提示中添加了5个指令-响应对作为示例。
3. 不同任务的性能比较：作者比较了LLMs在不同可控文本生成（CTG）任务上的性能，包括情感、主题、多方面、长度、关键词和毒性避免任务。
4. 错误分析：对于多方面可控生成任务和复杂关键词CTG任务，作者分析了GPT-3.5-turbo（ChatGPT）响应错误的原因。
5. 长度可控文本生成任务的子任务分析：作者计算了GPT-3.5-turbo在长度可控文本生成任务的各个子任务上的准确率，并发现准确率与目标长度的范围大致正相关。
6. 指令多样性分析：作者通过构建仅使用指令扩展步骤的指令集，并与CoDI-Eval中的最终指令集进行比较，来验证“指令多样化”步骤的有效性。
7. 评估方法的质量验证：作者通过人工判断来验证自动化评估方法的可靠性，特别是对于情感、主题和多方面控制任务。
8. 进一步讨论：作者讨论了LLMs在特定长度约束下生成文本的表现不佳的原因，并提出了可能的改进方向。

这些实验不仅展示了CoDI-Eval基准测试的评估能力，而且还揭示了当前LLMs在可控文本生成方面的局限性，特别是在处理特定约束时。实验结果为未来的研究方向提供了有价值的见解。

Q: 有什么可以进一步探索的点？

A: 根据论文内容，以下是一些可以进一步探索的点：

1. 改进长度感知能力：LLMs在处理长度约束方面表现不佳，需要研究如何提高模型对文本长度的感知和控制能力。
2. 增强指令理解：探索新的方法来提高LLMs对多样化指令的理解，特别是对于复杂或不常见的指令表达。
3. 优化少样本学习：研究如何通过少样本学习更有效地提高LLMs的可控文本生成能力，考虑到当前的简单示例可能不足以捕捉指令的多样性。
4. 指令多样化的自动化：尽管论文中提出了指令多样化的方法，但这个过程仍然可以进一步自动化和优化，以减少人工干预并提高效率。
5. 跨语言评估：探索CoDI-Eval基准测试在不同语言上的适用性，以及如何调整评估方法以适应不同的语言特性。
6. 模型架构改进：研究不同的模型架构和训练策略，以更好地处理带有约束的文本生成任务。
7. 实时性能评估：开发实时评估工具，以便在模型生成文本时即时评估其性能，这可能有助于提高交互式应用的用户体验。
8. 可解释性和透明度：提高LLMs在可控文本生成任务中的可解释性，帮助用户理解模型的决策过程。
9. 伦理和公平性：确保LLMs在生成文本时遵循伦理准则，避免产生有害或偏见的内容。
10. 多任务学习：研究LLMs在同时处理多个不同类型的可控文本生成任务时的性能，以及如何优化模型以提高多任务处理能力。
11. 数据集和基准测试的扩展：扩充CoDI-Eval数据集，添加更多的指令和任务类型，以更全面地评估LLMs的能力。
12. 用户研究：进行用户研究，以了解用户对LLMs生成的文本的满意度，以及他们对可控文本生成的具体需求。

这些探索点可以帮助研究者们更好地理解和改进LLMs在可控文本生成方面的表现，同时也为LLMs的实际应用提供指导。

Q: 总结一下论文的主要内容

A: 这篇论文的主要内容可以总结如下：

1. 问题定义：论文探讨了大型语言模型（LLMs）在遵循带有特定约束的自然语言指令方面的能力，并指出了现有评估方法的不足。
2. CoDI-Eval基准测试：提出了一个新的基准测试CoDI-Eval，用于系统和全面地评估LLMs对带有各种约束的指令的响应能力。
3. 测试套件构建：构建了一个大型的、具有约束属性的指令集合作为测试套件，这些指令覆盖了情感、主题、长度、关键词和毒性避免等多个方面。
4. 指令多样化：通过一个两步过程（扩展和多样化）来增加指令的多样性，使用LLMs自动生成指令并进行文本重写。
5. 自动化评估：开发了自动化的评估方法，使用开源模型和API来评估LLMs在各个CTG任务上的性能。
6. 实验验证：对多个主流LLMs进行了广泛的评估，包括商业模型和开源模型，揭示了它们在遵循特定约束指令方面的局限性。
7. 性能比较：比较了不同LLMs在CoDI-Eval上的性能，发现商业闭源模型通常优于开源模型。
8. 错误分析：对LLMs在多方面可控生成任务和复杂关键词CTG任务上的错误进行了分析。
9. 进一步讨论：讨论了LLMs在长度可控文本生成任务中的挑战，并提出了可能的改进方向。
10. 结论：论文得出结论，CoDI-Eval基准测试能够有效评估LLMs的可控文本生成能力，并指出了未来研究的潜在方向。

整体而言，这篇论文通过提出新的基准测试和评估方法，为理解和改进LLMs在可控文本生成方面的能力提供了重要的工具和见解。

大型语言模型（LLM）如ChatGPT和ChatGLM的出现，标志着人工智能领域取得了重大突破。它们展现出惊人的通用能力，能够胜任多种任务，例如文本生成、问答和翻译。然而，这些模型也存在一些固有的缺陷，例如事实性幻觉、知识过时以及缺乏领域专业知识。

为了克服这些缺陷，检索增强生成（RAG）应运而生。RAG通过将外部知识库与LLM结合，赋予模型更强大的信息获取能力，从而生成更准确、更可靠的答案。

RAG的四个关键能力

然而，RAG并非万能药。外部知识库中存在大量噪声信息，甚至虚假新闻，这给检索引擎带来了准确获取所需知识的挑战。另一方面，LLM本身也存在着不可靠的生成问题。它们可能被上下文中的错误信息误导，并在生成过程中出现幻觉，导致最终生成的文本超出外部信息的范围。

因此，为了更好地理解RAG在LLM中的应用，我们需要对LLM在RAG中所需要的关键能力进行评估。本文将探讨四个关键能力：

1. 噪声鲁棒性： LLM能够从包含噪声的文档中提取有用信息。噪声文档是指与问题相关，但并不包含答案信息的文档。例如，对于问题“谁获得了2022年诺贝尔文学奖？”，噪声文档可能包含关于2021年诺贝尔文学奖的报道。

2. 负面拒绝： 当检索到的文档中不包含所需知识时，LLM能够拒绝回答问题。在现实场景中，搜索引擎经常无法检索到包含答案的文档。在这种情况下，模型需要具备拒绝识别能力，避免生成误导性内容。

3. 信息整合： LLM能够整合来自多个文档的信息，回答复杂问题。例如，对于问题“ChatGPT的iOS应用和API分别在什么时候发布？”，LLM需要提供ChatGPT iOS应用和ChatGPT API的发布日期。

4. 反事实鲁棒性： LLM能够识别检索到的文档中已知事实错误的风险。当LLM通过指令被告知检索到的信息存在潜在风险时，它需要能够识别这些风险。

检索增强生成基准测试 (RGB)

为了对LLM在RAG中的能力进行评估，本文创建了检索增强生成基准测试 (RGB)。RGB包含英语和中文版本，旨在评估LLM在上述四个方面的能力。

RGB的构建过程如下：

1. 问答实例生成： 从最新的新闻文章中提取事件、问题和答案。例如，对于一篇关于“2022年诺贝尔奖”的报道，ChatGPT可以生成相应的事件、问题和关键信息。

2. 使用搜索引擎检索： 使用Google Search API检索与每个问题相关的网页，并提取相应的文本片段。同时，将这些网页的文本内容转换为长度不超过300个token的文本块。使用开源密集检索模型，选择与问题最匹配的30个文本块。这些检索到的文本块，以及搜索API提供的片段，将作为外部文档。

3. 构建每个能力的测试集： 根据LLM的四个基本能力，将数据集划分为四个测试集。为了评估噪声鲁棒性，根据所需的噪声比例，对负面文档进行抽样。对于负面拒绝，所有外部文档都来自负面文档。对于信息整合能力，根据已生成的问题，进一步构建数据。这包括扩展或改写这些问题，使其答案包含多个方面。例如，问题“谁获得了2023年超级碗的MVP？”可以改写为“谁获得了2022年和2023年超级碗的MVP？”。因此，回答这类问题需要利用来自多个文档的信息。与前三个能力不同，反事实鲁棒性的数据仅基于模型的内部知识构建。根据上述生成的问题，使用ChatGPT自动生成模型已知的知识。具体来说，使用提示让模型生成已知的问题和答案。例如，基于问题“谁获得了2022年诺贝尔生理学或医学奖？”，模型将生成已知问题“谁获得了2021年诺贝尔文学奖？”，并回答“阿卜杜勒拉扎克·古尔纳”。然后，手动验证生成的答案，并按照上述方法检索相关文档。为了使文档包含事实错误，手动修改答案，并替换文档中相应的部分。

最终，RGB包含600个基本问题，以及200个用于信息整合能力的额外问题和200个用于反事实鲁棒性能力的额外问题。其中一半的实例为英语，另一半为中文。

评估指标

RGB主要评估LLM是否能够利用提供的外部文档获取知识，并生成合理的答案。评估指标包括：

1. 准确率： 用于评估噪声鲁棒性和信息整合能力。采用精确匹配方法，如果生成的文本包含与答案完全匹配的部分，则视为正确答案。

2. 拒绝率： 用于评估负面拒绝能力。当仅提供噪声文档时，LLM应该输出特定内容 – “由于文档中信息不足，我无法回答这个问题。”（我们使用指令告知模型）。如果模型生成此内容，则表示成功拒绝。

3. 错误检测率： 用于评估模型是否能够检测文档中的事实错误（反事实鲁棒性）。当提供的文档包含事实错误时，模型应该输出特定内容 – “提供的文档中存在事实错误。”（我们使用指令告知模型）。如果模型生成此内容，则表示模型已检测到文档中的错误信息。

4. 错误纠正率： 用于评估模型在识别错误后是否能够提供正确答案（反事实鲁棒性）。要求模型在识别事实错误后生成正确答案。如果模型生成正确答案，则表示模型能够纠正文档中的错误。

实验结果与分析

本文对六个最先进的LLM进行了评估，包括ChatGPT、ChatGLM-6B、ChatGLM2-6B、Vicuna-7b、Qwen-7B-Chat和BELLE-7B。实验结果表明，尽管RAG可以提高LLM的响应准确率，但它们在上述四个方面仍然存在显著的挑战。

1. 噪声鲁棒性： 实验结果表明，LLM在一定程度上表现出噪声鲁棒性，但当存在相关信息时，它们倾向于混淆相似信息，并经常生成不准确的答案。例如，当面对关于2022年诺贝尔文学奖的问题时，如果外部文档中存在关于2021年诺贝尔文学奖的噪声文档，LLM可能会感到困惑，并提供不准确的答案。

2. 负面拒绝： 实验结果表明，当外部文档中不包含相关信息时，LLM经常无法拒绝回答问题，并生成错误的答案。

3. 信息整合： 实验结果表明，LLM缺乏从多个文档中进行总结的能力。因此，如果需要多个文档才能回答问题，LLM通常无法提供准确的答案。

4. 反事实鲁棒性： 实验结果表明，即使LLM包含所需知识，并通过指令被告知检索到的信息存在潜在风险，它们仍然倾向于相信并优先考虑检索到的信息，而不是它们自己的现有知识。

未来方向

实验结果表明，现有的RAG方法仍然存在一些重要的挑战，需要进一步解决。为了确保LLM能够生成准确可靠的答案，需要谨慎使用RAG，并进行精心设计。

未来研究方向包括：

• 提高模型对长文档的建模能力和精确概念理解能力。
• 增强LLM准确匹配问题与相应文档的能力。
• 提高模型对复杂问题的理解能力，并利用来自不同子问题的有效信息。
• 开发能够识别和纠正文档中事实错误的机制。

结论

本文对LLM在检索增强生成中的四个关键能力进行了评估，并构建了检索增强生成基准测试 (RGB)。实验结果表明，现有的LLM在四个方面都存在局限性。这表明，要有效地将RAG应用于LLM，还需要进行大量的研究工作。

参考文献

• Adlakha, V., BehnamGhader, P., Lu, X. H., Meade, N., & Reddy, S. (2023). Evaluating Correctness and Faithfulness of Instruction-Following Models for Question Answering. arXiv:2307.16877.
• Bai, J., Bai, S., Chu, Y., Cui, Z., Dang, K., Deng, X., … & Zhu, T. (2023). Qwen Technical Report. arXiv preprint arXiv:2309.16609.
• Bang, Y., Cahyawijaya, S., Lee, N., Dai, W., Su, D., … & Fung, P. (2023). A Multitask, Multilingual, Multi-modal Evaluation of ChatGPT on Reasoning, Hallucination, and Interactivity. arXiv:2302.04023.
• BELLEGroup. (2023). BELLE: Be Everyone’s Large Language model Engine. https://github.com/LianjiaTech/BELLE. Accessed: 2024-01-10.
• Bian, N., Liu, P., Han, X., Lin, H., Lu, Y., He, B., & Sun, L. (2023). A Drop of Ink Makes a Million Think: The Spread of False Information in Large Language Models. arXiv:2305.04812.
• Borgeaud, S., Mensch, A., Hoffmann, J., Cai, T., Rutherford, E., … & Sifre, L. (2022). Improving language models by retrieving from trillions of tokens. arXiv:2112.04426.
• Cai, D., Wang, Y., Bi, W., Tu, Z., Liu, X., Lam, W., & Shi, S. (2019a). Skeleton-to-Response: Dialogue Generation Guided by Retrieval Memory. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), 1219–1228. Minneapolis, Minnesota: Association for Computational Linguistics.
• Cai, D., Wang, Y., Bi, W., Tu, Z., Liu, X., & Shi, S. (2019b). Retrieval-guided Dialogue Response Generation via a Matching-to-Generation Framework. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), 1866–1875. Hong Kong, China: Association for Computational Linguistics.
• Cao, M., Dong, Y., Wu, J., & Cheung, J. C. K. (2020). Factual Error Correction for Abstractive Summarization Models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), 6251–6258. Online: Association for Computational Linguistics.
• Chang, Y., Wang, X., Wang, J., Wu, Y., Yang, L., … & Xie, X. (2023). A Survey on Evaluation of Large Language Models. arXiv:2307.03109.
• Chiang, W.-L., Li, Z., Lin, Z., Sheng, Y., Wu, Z., … & Xing, E. P. (2023). Vicuna: An Open-Source Chatbot Impressing GPT-4 with 90%* ChatGPT Quality.
• Cui, J., Li, Z., Yan, Y., Chen, B., & Yuan, L. (2023). ChatLaw: Open-Source Legal Large Language Model with Integrated External Knowledge Bases. arXiv:2306.16092.
• Drozdov, A., Sch¨arli, N., Aky¨urek, E., Scales, N., Song, X., … & Zhou, D. (2023). Compositional Semantic Parsing with Large Language Models. In The Eleventh International Conference on Learning Representations.
• Edward Beeching, N. H. S. H. N. L. N. R. O. S. L. T. T. W., Cl´ementine Fourrier. (2023). Open LLM Leaderboard. https://huggingface.co/spaces/HuggingFaceH4/open llm leaderboard. Accessed: 2024-01-10.
• Guo, B., Zhang, X., Wang, Z., Jiang, M., Nie, J., … & Wu, Y. (2023). How Close is ChatGPT to Human Experts? Comparison Corpus, Evaluation, and Detection. arXiv:2301.07597.
• Guu, K., Lee, K., Tung, Z., Pasupat, P., & Chang, M.-W. (2020). REALM: Retrieval-Augmented Language Model Pre-Training. In Proceedings of the 37th International Conference on Machine Learning, ICML’20. JMLR.org.
• He, H., Zhang, H., & Roth, D. (2022). Rethinking with Retrieval: Faithful Large Language Model Inference. arXiv:2301.00303.
• Hendrycks, D., Burns, C., Basart, S., Zou, A., Mazeika, M., … & Steinhardt, J. (2021). Measuring Massive Multitask Language Understanding. In International Conference on Learning Representations.
• Huang, Y., Bai, Y., Zhu, Z., Zhang, J., Zhang, J., … & He, J. (2023). C-Eval: A Multi-Level Multi-Discipline Chinese Evaluation Suite for Foundation Models. arXiv preprint arXiv:2305.08322.
• Izacard, G., & Grave, E. (2021). Leveraging Passage Retrieval with Generative Models for Open Domain Question Answering. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, 874–880. Online: Association for Computational Linguistics.
• Izacard, G., Lewis, P., Lomeli, M., Hosseini, L., Petroni, F., … & Grave, E. (2022). Atlas: Few-shot Learning with Retrieval Augmented Language Models. arXiv:2208.03299.
• Ji, Z., Lee, N., Frieske, R., Yu, T., Su, D., … & Fung, P. (2023). Survey of Hallucination in Natural Language Generation. ACM Comput. Surv., 55(12).
• Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., … & Kiela, D. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. In Proceedings of the 34th International Conference on Neural Information Processing Systems, NIPS’20. Red Hook, NY, USA: Curran Associates Inc. ISBN 9781713829546.
• Li, D., Rawat, A. S., Zaheer, M., Wang, X., Lukasik, M., … & Kumar, S. (2023a). Large Language Models with Controllable Working Memory. In Findings of the Association for Computational Linguistics: ACL 2023, 1774–1793. Toronto, Canada: Association for Computational Linguistics.
• Li, X., Zhang, T., Dubois, Y., Taori, R., Gulrajani, I., … & Hashimoto, T. B. (2023b). AlpacaEval: An Automatic Evaluator of Instruction-following Models. https://github.com/tatsu-lab/alpaca eval. Accessed: 2024-01-10.
• Li, X., Zhu, X., Ma, Z., Liu, X., & Shah, S. (2023c). Are ChatGPT and GPT-4 General-Purpose Solvers for Financial Text Analytics? An Examination on Several Typical Tasks. arXiv:2305.05862.
• Liu, N. F., Zhang, T., & Liang, P. (2023). Evaluating Verifiability in Generative Search Engines. arXiv:2304.09848.
• Maynez, J., Narayan, S., Bohnet, B., & McDonald, R. (2020). On Faithfulness and Factuality in Abstractive Summarization. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, 1906–1919. Online: Association for Computational Linguistics.
• OpenAI. (2022). Chatgpt: Optimizing language models for dialogue. https://openai.com/blog/chatgpt. Accessed: 2024-01-10.
• Peng, B., Galley, M., He, P., Cheng, H., Xie, Y., … & Gao, J. (2023). Check Your Facts and Try Again: Improving Large Language Models with External Knowledge and Automated Feedback. arXiv:2302.12813.
• Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., … & Sun, M. (2023). ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs. arXiv:2307.16789.
• Raunak, V., Menezes, A., & Junczys-Dowmunt, M. (2021). The Curious Case of Hallucinations in Neural Machine Translation. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 1172–1183. Online: Association for Computational Linguistics.
• Ren, R., Wang, Y., Qu, Y., Zhao, W. X., Liu, J., … & Wang, H. (2023). Investigating the Factual Knowledge Boundary of Large Language Models with Retrieval Augmentation. arXiv:2307.11019.

---

Q: 这篇论文试图解决什么问题？

A: 这篇论文探讨了如何通过检索增强生成（Retrieval-Augmented Generation, RAG）来减轻大型语言模型（Large Language Models, LLMs）的幻觉问题。幻觉问题指的是语言模型可能会生成与给定上下文无关或事实错误的信息。尽管RAG被认为是解决这一挑战的有前途的方法，但现有研究缺乏对RAG对不同LLMs影响的严格评估，这使得难以确定RAG在不同LLMs中的潜在瓶颈。

具体来说，论文的主要贡献和解决的问题包括：

1. 系统评估RAG对LLMs的影响：分析不同LLMs在RAG所需的4个基本能力上的表现，包括噪声鲁棒性、负面拒绝、信息集成和反事实鲁棒性。
2. 创建评估基准：创建了一个新的RAG评估语料库（Retrieval-Augmented Generation Benchmark, RGB），用于评估英文和中文的RAG性能。
3. 诊断当前LLMs的挑战：通过RGB评估6个代表性的LLMs，以诊断当前LLMs在应用RAG时面临的挑战。
4. 识别和提出改进方向：评估结果揭示了LLMs在噪声鲁棒性、负面拒绝、信息集成和处理错误信息方面的不足，并指出了有效应用RAG到LLMs的前进方向。
5. 提供数据和代码：论文还提供了相关的数据和代码，以促进进一步的研究和开发。

总体而言，这篇论文试图通过创建一个全面的评估基准来深入理解RAG在LLMs中的应用，并识别现有方法中的关键问题，从而为未来的研究提供指导。

Q: 有哪些相关研究？

A: 论文中提到的相关研究主要集中在以下几个领域：

1. 检索增强模型（Retrieval-Augmented Models）：这类研究探讨了如何通过检索外部知识来提高语言模型的生成准确性和可靠性。相关研究包括Guu et al. (2020), Lewis et al. (2020), Borgeaud et al. (2022), Izacard et al. (2022) 等。
2. 大型语言模型（Large Language Models, LLMs）的评估：这些研究关注于如何全面评估LLMs的能力，包括GLUE (Wang et al. 2019b), SuperCLUE (Wang et al. 2019a), MMLU (Hendrycks et al. 2021), AGIEval (Zhong et al. 2023), C-Eval (Huang et al. 2023), AlpacaEval (Li et al. 2023b), OpenLLM Leaderboard (Edward Beeching 2023) 等。
3. 处理噪声和错误信息：研究了LLMs在面对噪声信息和错误信息时的鲁棒性，例如Cao et al. (2020), Raunak, Menezes, and Junczys-Dowmunt (2021), Ji et al. (2023) 等。
4. 知识更新和领域特定专业知识：探讨了LLMs在知识更新和缺乏领域特定专业知识方面的挑战，如He, Zhang, and Roth (2022), Li et al. (2023c), Shen et al. (2023) 等。
5. 检索增强生成的评估：研究了如何在现有的问答数据集上评估LLMs的RAG能力，例如Adlakha et al. (2023)。
6. 安全性和责任：评估了LLMs在安全性和责任方面的表现，如CValues (Xu et al. 2023a)。
7. 人类考试和工具使用：研究了LLMs在模拟人类考试和工具使用方面的能力，如M3Exam (Zhang et al. 2023), ToolBench (Qin et al. 2023)。

这些相关研究为本文提出的RGB基准提供了理论和实证基础，并帮助确定了评估LLMs在RAG中所需能力的各个方面。

Q: 论文如何解决这个问题？

A: 论文通过以下几个步骤来解决大型语言模型（LLMs）在检索增强生成（RAG）中面临的挑战：

1. 定义四个基本能力：首先，论文定义了RAG所需的四个基本能力：噪声鲁棒性、负面拒绝、信息集成和反事实鲁棒性。
2. 构建评估基准（RGB）：为了评估这些能力，论文创建了一个新的评估基准，即检索增强生成基准（Retrieval-Augmented Generation Benchmark, RGB）。RGB使用最新的新闻文章来构建问题和答案数据，并通过网络搜索引擎检索外部文档。
3. 数据生成过程：通过使用ChatGPT生成事件、问题和答案，并利用搜索引擎API检索相关网页，然后使用密集检索模型重新排名这些网页的内容。
4. 构建测试床：根据上述基本能力，RGB将语料库扩展并划分为四个测试床，以评估LLMs的不同能力。
5. 评估指标：论文使用了准确性、拒绝率、错误检测率和错误修正率等指标来评估LLMs在RGB上的表现。
6. 实验：对六个现有的LLMs进行了评估，包括ChatGPT、ChatGLM-6B、ChatGLM2-6B、Vicuna-7B、Qwen-7B-Chat和BELLE-7B。实验结果揭示了LLMs在上述四个能力方面的局限性。
7. 错误分析：通过案例研究，论文分析了LLMs在噪声鲁棒性、负面拒绝和信息集成方面的典型错误，如长距离信息、证据不确定性和概念混淆。
8. 提出改进方向：基于评估结果和错误分析，论文讨论了LLMs在RAG应用中的挑战，并提出了可能的改进方向，如提高模型对复杂问题的理解能力和对错误信息的识别能力。
9. 谨慎使用RAG：论文最后强调，在有效应用RAG到LLMs之前，还有大量的工作要做，并建议在使用RAG时应该谨慎并仔细设计。

通过这些步骤，论文不仅评估了LLMs在RAG中的性能，还为未来的研究方向和LLMs的改进提供了指导。

Q: 论文做了哪些实验？

A: 论文中进行了一系列的实验来评估大型语言模型（LLMs）在检索增强生成（RAG）中的四个基本能力：噪声鲁棒性、负面拒绝、信息集成和反事实鲁棒性。具体的实验包括：

1. 噪声鲁棒性实验：通过在外部文档中引入不同比例的噪声（无关信息），评估LLMs在存在噪声时的准确性。实验结果表明，当噪声比例超过80%时，LLMs的准确性显着下降。
2. 负面拒绝实验：在只提供噪声文档的情况下，评估LLMs拒绝回答的能力。实验结果显示，LLMs在负面拒绝方面表现不佳，即使在只有噪声文档的情况下，它们也很少拒绝回答。
3. 信息集成实验：通过构造需要从多个文档中集成信息才能回答的问题，评估LLMs的信息集成能力。实验发现，LLMs在处理复杂问题时，即使没有噪声，准确性也较低，这表明它们在集成信息方面存在挑战。
4. 反事实鲁棒性实验：在提供包含事实错误的文档时，评估LLMs识别和纠正错误信息的能力。实验结果表明，LLMs很难识别文档中的错误并提供正确的答案。
5. 错误分析：对LLMs在上述实验中的错误回答进行了详细分析，以了解它们在RAG中的局限性。分析发现错误通常源于长距离信息、证据不确定性和概念混淆。
6. 模型性能比较：评估了六个代表性的LLMs，包括ChatGPT、ChatGLM-6B、ChatGLM2-6B、Vicuna-7B-v1.3、Qwen-7B-Chat和BELLE-7B-2M，并比较了它们在RGB基准上的性能。

这些实验提供了对LLMs在RAG中性能的全面评估，并揭示了它们在不同能力方面的不足，为未来的研究和模型改进提供了方向。

Q: 有什么可以进一步探索的点？

A: 根据论文内容，以下是一些可以进一步探索的点：

1. 改进噪声鲁棒性：研究如何提高LLMs在面对大量噪声信息时的鲁棒性，例如通过更好的信息检索技术或增强模型对噪声的识别能力。
2. 增强负面拒绝能力：开发机制让LLMs在检索到的信息不足以回答问题时能够更准确地拒绝回答，避免误导用户。
3. 提升信息集成能力：探索如何改进LLMs处理复杂问题时的信息集成能力，可能的研究方向包括改进模型的多文档理解和推理能力。
4. 反事实鲁棒性的提升：研究如何使LLMs更好地识别和纠正检索到的文档中的错误信息，这可能涉及到事实验证和错误检测算法的发展。
5. 模型推理能力：提高LLMs的推理能力，特别是在处理需要多步骤逻辑推理的复杂问题时。
6. 长文档处理：改进LLMs处理长文档的能力，这可能包括更好的文档摘要技术或对文档结构的理解。
7. 概念理解：加强LLMs对概念之间细微差别的理解，以减少概念混淆导致的错误。
8. 检索策略优化：研究更有效的检索策略，以提高检索到的信息质量和相关性。
9. 用户指令的更好集成：改进LLMs对用户指令的理解和执行，以提高对用户需求的响应能力。
10. 跨语言评估：扩展RGB基准到更多语言，并研究LLMs在不同语言和文化背景下的性能。
11. 实时性能：考虑到实际应用中对实时响应的需求，研究如何优化LLMs的推理速度，特别是在执行复杂的检索增强任务时。
12. 可解释性和透明度：提高LLMs在RAG过程中的可解释性，帮助用户理解模型的决策过程。
13. 安全性和隐私：在RAG的应用中，考虑数据的安全性和隐私保护，确保用户信息的安全。
14. 多模态信息检索：探索如何将多模态信息（如图像、视频）集成到RAG中，以提高生成内容的丰富性和准确性。

这些探索点可以帮助研究者们更好地理解和改进LLMs在RAG中的应用，同时也为未来的研究方向提供了可能的路径。

Q: 总结一下论文的主要内容

A: 这篇论文的主要内容可以总结如下：

1. 问题背景：大型语言模型（LLMs）在生成文本时存在幻觉问题，即生成与给定上下文无关或事实错误的信息。为了解决这一问题，研究者们提出了检索增强生成（RAG）方法。
2. 研究目的：论文旨在系统评估RAG对不同LLMs的影响，并识别在RAG中应用时的潜在瓶颈。
3. 四个基本能力：定义了RAG所需的四个基本能力：噪声鲁棒性、负面拒绝、信息集成和反事实鲁棒性。
4. RGB基准：创建了一个新的评估基准，即检索增强生成基准（RGB），用于评估LLMs在RAG中的性能。
5. 数据生成：通过最新的新闻文章生成问题和答案数据，并使用搜索引擎API检索相关文档。
6. 测试床构建：根据四个基本能力，将数据集划分为四个测试床，以评估LLMs的不同能力。
7. 评估指标：使用准确性、拒绝率、错误检测率和错误修正率等指标来评估LLMs的性能。
8. 实验结果：对六个代表性的LLMs进行了评估，发现它们在噪声鲁棒性、负面拒绝、信息集成和反事实鲁棒性方面存在挑战。
9. 错误分析：通过案例研究分析了LLMs在RAG中的错误，发现错误通常源于长距离信息、证据不确定性和概念混淆。
10. 改进方向：基于评估结果和错误分析，论文讨论了LLMs在RAG应用中的挑战，并提出了可能的改进方向。
11. 结论：指出了LLMs在RAG中的局限性，并强调了在实际应用中需要谨慎使用RAG，同时提出了未来研究的方向。
12. 贡献：论文的贡献包括提出了评估RAG的四个能力、创建了RGB基准、评估了现有LLMs的局限性，并分析了它们的响应，为改进RAG方法提供了方向。
13. 支持与资助：研究工作得到了中国国家自然科学基金、中国科学院青年科学家基础研究项目和北京市科学技术委员会的支持。

这篇文章深入探讨了人工智能领域的一个重要问题：AI 幻觉。作者从多个角度剖析了 AI 幻觉的定义、产生原因、潜在风险以及应对策略，并探讨了 AI 幻觉与人类认知偏差之间的关系，最后对 AI 的未来发展提出了展望。

一、什么是 AI 幻觉？

AI 幻觉是指 AI 系统生成的输出内容看似合理流畅，但实际上与输入信息、上下文环境或客观事实相矛盾，缺乏逻辑或经验支撑。简单来说，就像 AI 在“一本正经地胡说八道”。

文章中列举了 AI 幻觉的几种表现形式：

• 事实性幻觉： AI 生成的内容与客观事实不符。例如，AI 错误地回答“谁是第一个登上月球的人？”
• 语义性幻觉： AI 对输入信息的语义理解出现偏差。例如，用户要求 AI 翻译“What is the capital of France?”，AI 却回答了“法国的首都是巴黎”。
• 上下文幻觉： AI 忽略了上下文信息。例如，在一段对话中，AI 首先说“今天天气晴朗”，然后又说“记得带伞，今天有雨”。
• 逻辑性幻觉： AI 生成的内容存在逻辑矛盾。例如，AI 在做数学题时，推理步骤正确，但最终答案却是错误的。

二、AI 幻觉产生的原因

文章从多个方面分析了 AI 幻觉产生的原因，将其比喻为多米诺骨牌效应，环环相扣：

• 数据质量的“陷阱”：
  • 信息污染： 训练数据中包含虚假信息，AI 可能会将其当作“真理”。
  • 偏见陷阱： 训练数据存在偏见，AI 可能会将其“内化”，并在输出内容时表现出来。
  • 知识断层： 训练数据缺乏某个领域的知识，或知识更新不及时，AI 在回答相关问题时就可能“抓瞎”，只能靠“编造”来应付。
• 模型自身的能力缺陷：
  • 结构简单，理解力不足： AI 模型的结构过于简单，理解能力有限，容易出现误解或曲解。
  • 注意力不集中，抓不住重点： AI 模型在处理信息时，可能会忽略重要的信息，而过度关注无关的信息，导致输出内容“文不对题”。
  • 推理能力不足，逻辑混乱： AI 模型缺乏推理能力，可能生成逻辑混乱的文本，甚至自相矛盾。
• 训练方法的缺陷：
  • 学习模式单一，缺乏灵活性： 传统的 AI 训练方法缺乏灵活性，导致模型在面对新的、未见过的样本时，容易“不知所措”，只能根据已有的知识进行猜测，从而产生幻觉。
  • 过度依赖“标准答案”，缺乏创造力： AI 模型在训练过程中过度依赖“标准答案”，会限制其创造力，导致其在面对开放性问题时，无法生成新颖的、有创意的答案。
• 推理过程的随机性： AI 模型在生成内容时，通常会根据概率分布来选择最有可能出现的词语或像素，这种随机性虽然可以增加 AI 模型的创造力和多样性，但也可能导致 AI 产生“口误”。

三、AI 幻觉的风险

AI 幻觉看似“小错误”，但在实际应用中可能带来巨大风险：

• 误导用户： AI 幻觉会导致用户获取错误信息，从而做出错误判断。
• 传播虚假信息： AI 幻觉可能被用于制造和传播虚假信息，误导公众，影响社会稳定。
• 损害 AI 系统的可信度： AI 幻觉会降低用户对 AI 系统的信任度，阻碍 AI 技术推广和应用。

四、AI 幻觉与人类认知偏差的比较

文章将 AI 幻觉与人类认知偏差进行了比较，指出两者既有相似之处，也有本质区别：

• 相似之处： 两者都指向对信息的扭曲或误解，都可能导致信息偏差和逻辑错误。
• 本质区别： 人类认知偏差根源于人类的心理和生理机制，而 AI 幻觉源于 AI 系统的技术局限性。

五、应对 AI 幻觉的技术手段

为了“驯服” AI 幻觉，研究人员开发了多种技术手段：

• 数据“体检”： 为 AI 模型提供“干净”、“健康”的训练数据，包括数据清洗和数据增强。
• “改造大脑”： 优化 AI 模型本身，包括模型编辑和提示工程。
• “知识外挂”： 为 AI 模型提供外部知识的支持，例如检索增强生成 (RAG) 技术。
• “对抗训练”： 让 AI 模型在训练过程中就接触到“恶意”样本，并学会如何识别和抵抗它们。
• 精准“操控”： 利用“提示词工程”，用精准指令来引导 AI 生成更可靠的内容。

六、AI 幻觉无法完全避免

尽管有多种应对措施，但 AI 幻觉无法从根本上避免，这源于 AI 技术本身的局限性：

• AI 的知识来源于数据： AI 的知识无法超越其训练数据的范围。
• AI 的推理能力有限： AI 无法像人类一样进行无限的推理和联想。

七、AI 幻觉的另一面：意外的惊喜

AI 幻觉也可能为我们带来意想不到的惊喜：

• 激发人类创造力： AI 幻觉有时会产生一些新颖、奇特、甚至超越人类想象力的内容，为艺术创作和科学研究提供灵感。
• 加速技术进步： AI 幻觉的出现，也反映了 AI 技术发展过程中的试错过程，每一次幻觉，都是 AI 模型的一次“学习”和“成长”。

八、与 AI 共舞：在挑战中寻求机遇

AI 幻觉是一把双刃剑，既带来风险，也蕴藏机遇。

• 人类的智慧：引导 AI 向善： 我们需要制定 AI 伦理规范，加强 AI 监管，提升公众的 AI 素养，引导 AI 技术健康发展。
• AI 的未来：谨慎的乐观： 我们需要辩证地看待 AI 幻觉，在积极探索 AI 的无限可能的同时，也要保持谨慎的态度，时刻警惕 AI 潜在的风险。

总而言之，AI 幻觉是人工智能发展道路上不可回避的挑战，但也是推动技术进步和激发人类创造力的机遇。我们需要正视 AI 幻觉，积极探索应对策略，并以负责任的态度引导 AI 技术发展，让 AI 真正造福人类社会。

引言

近年来，随着大型语言模型（LLM）和大型多模态模型（LMM）的飞速发展，人工智能（AI）在解决问题和科学发现（即 AI4Science）方面的认知推理能力逐渐显现，展现出与人类智慧相媲美的潜力。为了全面评估当前模型在认知推理能力方面的表现，我们推出了“奥运竞技场” (OlympicArena) 基准测试，它包含了 11,163 个双语问题，涵盖了文本和文本-图像混合两种模式。这些挑战涵盖了七个领域和 62 个国际奥林匹克竞赛，并经过严格审查以确保数据泄露问题。我们认为，奥林匹克竞赛中的问题是评估 AI 认知推理能力的理想选择，因为它们具有复杂性和跨学科性，这对解决复杂的科学挑战和促进发现至关重要。

除了使用仅答案的标准评估不同学科的表现外，我们还从多个角度进行了详细的实验和分析。我们深入研究了模型的认知推理能力、它们在不同模式下的表现，以及它们在过程级评估中的结果，这对于需要复杂推理和长篇解决方案的任务至关重要。我们广泛的评估结果表明，即使是像 GPT-4o 这样先进的模型，其总体准确率也仅为 39.97%（数学为 28.67%，物理为 29.71%），这说明了当前 AI 在复杂推理和多模态整合方面的局限性。

通过“奥运竞技场”，我们旨在推动 AI 向超级智能发展，使其能够应对科学及其他领域中更复杂的挑战。我们还提供了一套全面的资源来支持 AI 研究，包括基准数据集、开源标注平台、详细的评估工具以及具有自动提交功能的排行榜。

为什么选择奥林匹克竞赛问题？

奥林匹克竞赛问题之所以成为评估 AI 认知推理能力的理想选择，主要有以下几个原因：

• 复杂性: 这些问题通常涉及多个学科的概念和原理，需要模型能够进行综合性的分析和推理。
• 跨学科性: 许多问题需要将不同学科的知识整合在一起，例如物理学和数学的结合，这考验了模型的知识迁移能力。
• 创造性: 这些问题往往需要模型能够进行抽象思考和创造性解决问题，这与人类的认知推理能力密切相关。

“奥运竞技场” 的设计

“奥运竞技场” 基准测试具有以下特点：

• 多学科: 涵盖数学、物理、化学、生物、地理、天文学和计算机科学七个学科，共计 34 个专业分支。
• 多模态: 包括文本和文本-图像混合两种模式，更接近现实世界的应用场景。
• 双语: 提供英语和中文版本，方便全球范围内的研究人员使用。
• 过程级评估: 除了评估最终答案的正确性，还评估模型推理过程的合理性和有效性，更全面地评估模型的认知推理能力。

实验结果

我们对各种 LLM 和 LMM 进行了实验，包括 GPT-4o、LLaVa-NeXT 等模型。实验结果表明：

• 当前 AI 模型在解决复杂的多学科问题方面仍然存在局限性。 即使是最先进的模型 GPT-4o，其总体准确率也仅为 39.97%，而其他开源模型的准确率甚至低于 20%。
• LMM 在处理复杂的多学科问题时，在利用视觉信息方面表现不佳。 许多 LMM 在处理图像时没有表现出比文本模式更好的性能，甚至一些模型的性能还有所下降。
• 过程级评估结果表明，大多数模型能够正确执行一些推理步骤，即使最终答案是错误的。 这表明模型在认知推理方面具有很大的潜力。

未来展望

“奥运竞技场” 基准测试为评估 AI 的认知推理能力提供了一个新的平台，它将推动 AI 在科学和工程领域的发展。未来，我们希望能够：

• 开发更强大的 AI 模型，能够更好地解决复杂的多学科问题。
• 改进 LMM 的视觉信息处理能力，使其能够有效地利用视觉信息进行推理。
• 探索更有效的过程级评估方法，更准确地评估模型的推理过程。

参考文献

[1] Zhen Huang, Zengzhi Wang, Shijie Xia, Xuefeng Li, Haoyang Zou, Ruijie Xu, Run-Ze Fan, Lyumanshan Ye, Ethan Chern, Yixin Ye, Yikai Zhang, Yuqing Yang, Ting Wu, Binjie Wang, Shichao Sun, Yang Xiao, Yiyuan Li, Fan Zhou, Steffi Chern, Yiwei Qin, Yan Ma, Jiadi Su, Yixiu Liu, Yuxiang Zheng, Shaoting Zhang, Dahua Lin, Yu Qiao, Pengfei Liu. OlympicArena: Benchmarking Multi-discipline Cognitive Reasoning for Superintelligent AI. arXiv preprint arXiv:2406.12753, 2024.

[2] Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. GPT-4 technical report. arXiv preprint arXiv:2303.08774, 2023.

[3] GPT-4v(ision) system card. 2023. URL https://api.semanticscholar.org/CorpusID:332263218031.

---

Q: 这篇论文试图解决什么问题？

A: 这篇论文介绍了一个名为”OlympicArena”的基准测试，旨在全面评估和推进人工智能（AI）在认知推理能力方面的表现。具体来说，它试图解决的问题包括：

1. 现有AI模型在复杂推理任务上的限制：尽管大型语言模型（LLMs）和大型多模态模型（LMMs）在某些领域表现出色，但在解决跨学科、需要高级认知推理能力的复杂问题上仍有局限。
2. 缺乏全面的评估机制：现有的基准测试多关注于知识密集型任务或简单的概念应用，缺乏对AI模型在更高层次认知推理能力上的系统和细粒度评估。
3. 多学科和多模态挑战的缺乏：目前的基准测试主要集中在单一学科或文本模态，而现实世界的问题往往涉及多个领域，并且可能需要处理文本和图像等多种模态的信息。
4. 数据泄露问题的检测和解决：随着预训练语料库规模的增加，检测潜在的基准泄露成为一个重要问题，这可能会影响模型评估的准确性和可靠性。
5. 推动AI向超智能（superintelligence）发展：通过构建一个具有挑战性的基准测试，激励AI研究社区开发能够处理更复杂科学挑战的模型，并在科学和其他领域实现应用。

为了解决这些问题，论文提出了”OlympicArena”，这是一个包含11,163个双语问题的综合基准测试，覆盖了七个领域和62个国际奥林匹克竞赛级别的挑战。该基准测试不仅关注答案的正确性，还包括对AI模型解题过程的详细评估，以深入理解其认知推理的深度和可靠性。

Q: 有哪些相关研究？

A: 论文中提到了多个与AI基准测试和认知推理相关的研究工作。以下是一些主要的相关研究：

1. 大型语言模型（LLMs）和大型多模态模型（LMMs）：这些模型在人工智能的发展历程中具有里程碑意义，它们在处理复杂任务时展现出了显着的认知推理能力。
2. 国际数学奥林匹克（IMO）：论文中提到了使用AI代理解决类似于国际数学奥林匹克中出现的复杂挑战。
3. AI4Science：指利用AI推动科学发现的研究领域，论文中提到了AI在这一领域的应用。
4. 现有基准测试：如MMLU、AGIEval、C-Eval和CMMLU等，这些基准测试推动了语言模型在多学科、多语言和知识密集型任务上的能力评估。
5. 特定学科的基准测试：例如GSM8K（针对小学数学推理问题）、MATH（引入高中级数学竞赛任务）等。
6. 多学科大学级别科目和多模态任务的基准测试：如JEEBench、SciBench、GPQA和MMMU等，这些基准测试扩展了评估范围，包括了多学科大学级别的科目。
7. 国际奥林匹克竞赛问题：论文中提到了使用国际奥林匹克竞赛级别的问题来挑战AI系统。
8. 算法挑战：涉及使用算法解决复杂问题的挑战，如论文中提到的一些相关工作。
9. 过程级评估：一些研究工作开始关注模型的中间推理步骤，例如使用过程监督来训练更好的奖励模型。
10. 数据泄露检测：随着预训练语料库规模的增加，检测潜在的基准泄露成为一个重要问题，论文中提到了一些相关工作。

这些相关研究为构建”OlympicArena”基准测试提供了理论和实践基础，并帮助确定了评估AI认知推理能力的需求和方法。论文通过比较和分析这些相关工作，展示了”OlympicArena”在评估AI能力方面的创新和全面性。

Q: 论文如何解决这个问题？

A: 论文通过以下几个关键步骤来解决AI在复杂认知推理任务上的评估问题：

1. 创建综合基准测试：“OlympicArena”是一个包含11,163个双语问题的综合基准测试，覆盖了数学、物理、化学、生物学、地理、天文学和计算机科学等七个领域的62个不同的奥林匹克级别的竞赛。
2. 多模态和多学科问题：基准测试包括文本和图像混合的问题，以模拟现实世界中的复杂场景，并要求AI模型能够处理和推理跨学科的问题。
3. 细粒度评估机制：除了传统的答案正确性评估（答案级评估），论文还引入了过程级评估，以深入分析AI模型的推理过程和步骤，从而更全面地理解其认知推理能力。
4. 数据泄露检测：为了确保评估的有效性和公正性，论文进行了数据泄露检测实验，以验证基准测试的难度和挑战性。
5. 实验和分析：论文对现有的顶级语言模型（包括专有模型和开源模型）进行了一系列的实验，从答案级和过程级两个角度进行了全面的评估。
6. 资源提供：为了支持AI研究，论文提供了一套全面的资源，包括基准数据集、开源注释平台、详细的评估工具和具有自动提交功能的排行榜。
7. 认知推理能力的分类：论文将认知推理能力细分为逻辑推理和视觉推理两大类，进一步将它们分为多个子类别，以便更细致地评估AI模型在不同认知推理方面的能力。
8. 错误分析和数据泄露检测：通过分析模型的错误和进行数据泄露检测，论文揭示了当前AI模型在复杂推理任务上的局限性，并为改进训练策略和提升认知推理能力提供了见解。

通过这些方法，论文不仅提出了一个全面的评估框架，而且通过实验结果揭示了即使是最先进的模型（如GPT-4o）在处理复杂、多学科问题时也存在显着的局限性，从而为AI的进一步发展提供了明确的方向和目标。

Q: 论文做了哪些实验？

A: 论文中进行了一系列实验来评估不同大型语言模型（LLMs）和大型多模态模型（LMMs）在“OlympicArena”基准测试上的表现。以下是实验的主要方面：

1. 实验设置：设计了三种不同的设置来评估模型：多模态（interleaved text and images）、图像-标题（image-caption）和纯文本（text-only）。
2. 模型选择：评估了包括专有模型（如GPT-4o）和开源模型（如LLaVa-NeXT）在内的多种LLMs和LMMs。
3. 零样本提示（Zero-shot Prompts）：为了减少偏差并公平评估模型，使用了零样本提示，并针对每种答案类型定制了输出格式。
4. 答案级评估（Answer-level Evaluation）：结合了基于规则的方法和基于模型的方法来评估各种类型的问题。对于固定答案的问题，使用规则匹配；对于编程任务，使用pass@k指标；对于难以用规则匹配评估的问题，使用GPT-4V作为评估器。
5. 过程级评估（Process-level Evaluation）：对模型生成的解决方案进行结构化步骤格式的转换，并使用GPT-4V对每个步骤的正确性进行评分。
6. 主要结果：展示了不同模型在“OlympicArena”上的表现，包括整体准确率和各个学科的准确率。
7. 细粒度分析（Fine-grained Analysis）：基于不同模态和推理能力对实验结果进行了更深入的评估和分析。
8. 过程级评估结果分析：通过比较过程级评估和答案级评估的一致性，以及分析错误步骤的位置分布，来洞察模型在认知推理上的潜力和挑战。
9. 错误分析：通过人工评估员对GPT-4V的不正确响应进行分析和注释，以识别错误的原因。
10. 数据泄露检测：使用N-gram预测准确率来检测预训练语料库中可能的基准泄露，并分析了不同模型在泄露实例上的表现。

这些实验提供了对当前AI模型在复杂认知推理任务上能力的全面评估，并揭示了它们在处理多学科、多模态问题时的局限性和潜力。

Q: 有什么可以进一步探索的点？

A: 尽管”OlympicArena”基准测试为评估AI的认知推理能力提供了一个全面的平台，但论文也指出了一些局限性，并提出了未来工作的几个方向，这些可以作为进一步探索的点：

1. 改进基准测试：通过社区反馈不断优化和改进基准测试，减少其中的噪声问题。
2. 年度更新：定期更新基准测试版本，以应对数据泄露问题，并确保评估的公正性和有效性。
3. 扩展评估范围：目前基准测试主要集中在问题解决能力上，未来可以扩展到评估AI在更广泛的复杂任务和实际应用中的表现，如AI4Science和AI4Engineering。
4. 增强模型的多模态能力：研究和开发能够更好地处理和集成多模态信息（文本、图像等）的模型。
5. 提升过程级评估：进一步研究和改进过程级评估方法，以便更准确地评估模型的推理过程和步骤。
6. 深入分析错误类型：通过对模型错误进行更深入的分类和分析，识别当前模型在认知推理上的薄弱环节。
7. 开发新的评估工具和方法：为了更全面地评估AI的能力，可以开发新的工具和方法，包括更先进的数据泄露检测工具。
8. 探索模型的可解释性：提高模型的可解释性，以便更好地理解其决策过程和推理逻辑。
9. 优化模型训练策略：基于基准测试的发现，探索新的模型训练策略，以提高模型在复杂推理任务上的性能。
10. 促进跨学科应用：研究如何将AI的认知推理能力应用于跨学科领域，解决现实世界中的复杂问题。
11. 伦理和社会影响：随着AI能力的提升，需要持续关注其潜在的伦理和社会影响，并进行相应的研究和讨论。
12. 模型鲁棒性：研究如何提高模型在面对错误或不完整信息时的鲁棒性。

这些探索点不仅可以推动AI技术的发展，还有助于确保AI技术的负责任使用和对社会的积极贡献。

Q: 总结一下论文的主要内容

A: 这篇论文介绍了”OlympicArena”，一个旨在全面评估和提升人工智能（AI）在认知推理能力方面的基准测试平台。以下是论文的主要内容总结：

1. 背景与动机：随着大型语言模型（LLMs）和大型多模态模型（LMMs）的发展，AI在认知推理方面展现出巨大潜力。然而，现有的基准测试多关注于知识密集型任务，缺乏对高级认知推理能力的评估。
2. OlympicArena基准测试：为了填补这一空白，作者提出了”OlympicArena”，一个包含11,163个双语问题的综合基准测试，覆盖数学、物理、化学、生物学、地理、天文学和计算机科学等七个领域。
3. 多模态和多学科问题：基准测试包括文本和图像混合的问题，以模拟现实世界的复杂性，并要求AI模型能够处理跨学科的问题。
4. 细粒度评估：除了答案正确性的评估，还包括过程级评估，以深入分析AI模型的推理过程。
5. 实验与分析：论文对现有的顶级语言模型进行了实验，包括专有模型（如GPT-4o）和开源模型（如LLaVa-NeXT）。实验结果表明，即使是最先进的模型，在处理复杂问题时也存在显着的局限性。
6. 认知推理能力的分类：将认知推理能力细分为逻辑推理和视觉推理两大类，并进一步细分为多个子类别，以便更细致地评估AI模型的能力。
7. 错误分析与数据泄露检测：通过分析模型的错误和进行数据泄露检测，揭示了AI模型在认知推理任务上的不足，并为改进模型提供了见解。
8. 资源提供：为了支持AI研究，论文提供了基准数据集、开源注释平台、评估工具和具有自动提交功能的排行榜。
9. 未来工作：论文提出了未来工作的方向，包括改进基准测试、扩展评估范围、增强模型的多模态能力等。
10. 社会影响考量：讨论了随着AI能力提升可能带来的伦理和道德风险，强调了进行集体监管的必要性。

“OlympicArena”基准测试的推出，旨在推动AI向超智能发展，并在科学和其他领域实现更广泛的应用。论文通过一系列实验和分析，展示了AI在复杂认知推理任务上的现状和挑战，并为未来的研究提供了明确的方向。

你是否曾为如何让学生更容易理解复杂的教育材料而烦恼？或者你是否需要将原本复杂的文字简化，使其更易于大众理解？现在，借助强大的语言模型 (LLM)，我们可以实现自动生成不同阅读难度的教育材料，让学习变得更轻松！

这篇文章将带你走进一个全新的领域——文本难度等级生成，并探讨如何利用LLM来实现这一目标。

文本难度等级生成：让学习更有效

众所周知，学生更容易从与自身阅读水平相匹配的材料中学习。过难的材料会造成理解障碍，而过简单的材料则无法带来有效提升。因此，根据学生的不同阅读能力生成不同难度的教育材料，对于提高学习效率至关重要。

传统的文本难度等级调整方法通常需要人工进行反复编辑，以确保修改后的文本符合目标难度标准。然而，这个过程并不容易，尤其是对于年轻的学习者而言，需要考虑更多因素，例如词汇的解码难度、信息量以及其他语言特征等。

文本难度等级生成任务的目标是：给定一篇源文本及其阅读难度等级，以及目标阅读难度等级，将源文本改写成符合目标难度等级的文本，同时保留其原意。

LLM助力文本难度等级生成：潜力与挑战

近年来，LLM在文本生成领域取得了显著进展，也为文本难度等级生成任务提供了新的可能性。

研究人员使用GPT-3.5、LLaMA-2 70B和Mixtral 8x7B这三种流行的LLM，对100篇教育材料进行了测试，发现通过少样本提示 (few-shot prompting) 可以显著提高LLM在文本难度等级调整和信息保留方面的表现。

其中，LLaMA-2 70B在实现目标难度范围方面表现更出色，而GPT-3.5则在保留原文意思方面表现更优。

然而，人工检查发现了一些问题，例如模型可能会引入错误信息，例如修改引文或出现事实性错误，以及文本编辑不均匀，导致文章的阅读难度不一致。这些问题提醒我们，在使用LLM生成教育材料时，需要谨慎对待，并进行进一步研究，以确保生成内容的质量。

文本难度等级生成：未来的发展方向

尽管LLM在文本难度等级生成方面展现出巨大潜力，但仍需克服一些挑战。

• 文本缩短和扩展： 调整文本难度可能需要缩短或扩展文本。LLM擅长使用高级提示技术（例如Chain-of-Density）来缩短文本，但扩展文本则需要引入新的信息。对于科学和新闻等事实性内容，保持准确性和最小化错误信息至关重要。
• 文本难度等级的局限性： 对于科学材料，尤其是针对年轻学习者的材料，文本难度等级生成可能并不适用于所有难度等级。简单地改写句子或选择常用词语，可能无法有效地改变文本难度。
• 融入教育元素： 教育材料通常包含学习目标，例如语法、词汇、知识等。如何将这些教育元素融入改写后的文本，仍然是一个未解决的挑战。
• 重要信息保留： 内容创作者需要保留特定的信息，例如关键术语、重要句子或特定部分。LLM可以通过提示工程来解决这个问题，但需要开发一个直观的界面，让用户可以突出显示需要保留的文本区域，并验证生成的文本是否符合这些要求。
• 模型偏差： 研究人员发现，当前的LLM存在一些偏差。例如，模型倾向于生成比原文更短的文本，无论目标是简化还是复杂化文本。此外，文本编辑的分布也不均匀，一些段落保持不变，而另一些段落则进行了大幅修改。这种不一致的编辑模式不适合教育材料。

总结：LLM赋能教育内容生成

文本难度等级生成是一个充满挑战但又充满希望的领域。LLM在调整文本复杂性和保留内容意思方面展现出巨大潜力，但仍需进一步研究，以解决教育内容的细微需求，例如信息准确性、学习目标的融入以及关键信息的保留，从而提升文本难度等级生成过程的质量。

相信随着技术的不断发展，LLM将成为教育内容生成的有力工具，为学生提供更优质、更个性化的学习体验。

参考文献：

• [1] Huang, Chieh-Yang, Jing Wei, and Ting-Hao Kenneth Huang. “Generating Educational Materials with Different Levels of Readability using LLMs.” In2Writing 2024, May 11, 2024, Honolulu, Hawii.
• [2] MetaMetrics. 2022. Lexile Framework for Reading Development and Validity Evidence. https://hubsupport.lexile.com/Images/Lexile%20Framework%20for%2020Reading%20Validity%20Evidence_2022.pdf

---

Q: 这篇论文试图解决什么问题？

A: 这篇论文介绍了一个名为“分级文本生成”(leveled-text generation)的任务，旨在将教育材料改写成特定的可读性水平，同时保持原有内容的意义不变。具体来说，这项研究试图通过使用大型语言模型（LLMs），如GPT-3.5、LLaMA-2 70B和Mixtral 8x7B，来实现以下目标：

1. 调整可读性：将源文本改写，使其达到预期的可读性水平，这通常通过改变词汇使用、句子结构、句子长度等语言特征来实现。
2. 保持信息：在改写过程中，确保文本的原始意义和信息得到保留。

这项任务的动机是，研究表明学生从与他们阅读能力相匹配的阅读材料中学习更为有效，这样可以在提高和认知负荷之间达到最佳平衡。因此，为学生提供不同复杂度的教育内容是实现更好学习成果的关键步骤。论文中提到，尽管这个过程看起来简单，但准确调整这些元素以达到目标阅读难度实际上是具有挑战性的，尤其是对于年轻学习者，还需要考虑诸如可解码性、信息负载等因素。

此外，论文还强调了在生成教育内容时确保质量的重要性，包括避免引入错误信息和保持文本编辑的一致性。这些发现突出了进一步研究的必要性，以确保生成的教育内容的质量。

Q: 有哪些相关研究？

A: 论文中提到了与分级文本生成任务相关的两个主要研究领域：文本可读性调整和教育内容生成。以下是一些具体的相关研究：

1. 文本可读性调整：
   • S. Bautista 等人通过基于规则的转换和使用简单同义词替换难词来进行文本简化。
   • Bingel 和 Søgaard 使用条件随机场对依赖图进行文本简化，预测压缩和释义。
   • Swain 等人利用 WordNet 模型开发了一种高效的文本简化技术。
   • Alkaldi 和 Inkpen 训练了自己的可读性分类器，并设计了一个基于 GRU 串行到串行模型的强化学习框架。
   • Feng 等人研究了大型语言模型在零样本和少样本学习中的表现。
   • Maddela 等人引入了结合语言规则和神经释义模型的混合方法。
2. 教育内容生成：
   • Leiker 等人调查了使用大型语言模型创建成人学习内容的潜力。
   • MacNeil 等人专注于自动生成计算机科学学习材料。
   • Gao 等人特别研究了大型语言模型在口语学习中的应用。
   • Jury 等人评估了在初级编程课程中使用大型语言模型生成的工作示例。
   • Xiao 等人将大型语言模型应用于生成阅读理解练习。

这些研究为本文提出的分级文本生成任务提供了理论和技术基础，并展示了大型语言模型在教育领域的应用潜力。然而，这些研究大多集中在文本简化或特定类型的教育内容生成上，而本文的研究重点是利用大型语言模型来调整文本的可读性水平，以适应不同阅读能力的学习者。

Q: 论文如何解决这个问题？

A: 论文通过以下几个步骤来解决分级文本生成任务：

1. 任务定义：首先定义了分级文本生成任务的目标，即在保持原始意义的同时，将给定文本改写为特定的可读性水平。
2. 使用大型语言模型（LLMs）：评估了三种不同的大型语言模型（GPT-3.5、LLaMA-2 70B和Mixtral 8x7B）在零样本学习和少样本学习环境下生成不同可读性水平内容的能力。
3. 数据集构建：创建了一个包含30,000对分级文本的并行数据集，这些文本对共享相同的主题，但写在不同的可读性水平上。
4. 评估指标：使用了多种评估指标，包括平均绝对误差（MAE）、匹配率和方向准确性来衡量文本是否被正确地改写到目标Lexile分数，同时使用BERTScores、语义相似性和归一化编辑距离来评估信息的保留情况。
5. 实验设计：设计了零样本学习和少样本学习的实验，其中少样本学习中包括1次、3次和5次样本的实验，以探索提供示例对模型性能的影响。
6. 结果分析：分析了不同模型在调整可读性和内容保留方面的表现，并进行了手动检查，以识别潜在的问题，如信息误引入和编辑分布的不一致性。
7. 问题识别与讨论：通过手动检查10篇文章，识别了使用这些输出作为教育材料可能存在的问题，并讨论了这些问题。
8. 未来研究方向：基于实验结果和手动检查的发现，提出了未来研究的方向，以解决当前模型的局限性和偏见，提高分级文本生成任务的质量。

通过这些步骤，论文不仅展示了当前大型语言模型在分级文本生成任务上的能力，还指出了需要进一步研究的领域，以确保生成的教育内容的质量。

Q: 论文做了哪些实验？

A: 论文中进行了以下实验来评估和分析分级文本生成任务：

1. 数据集构建：创建了一个并行数据集，包含30,000对分级文本，这些文本对覆盖相同的主题但具有不同的可读性水平。
2. 零样本学习（Zero-shot Learning）：在没有提供任何示例的情况下，仅通过定义Lexile分数和提供源文本、源Lexile分数以及目标Lexile分数来测试模型的性能。
3. 少样本学习（Few-shot Learning）：在提供来自训练集的实际示例的情况下，教导模型特定可读性水平的文本应该是什么样子。实验中尝试了1次、3次和5次样本的少样本学习。
4. 性能评估：使用以下指标来评估模型性能：
   • 平均绝对误差（MAE）：目标Lexile分数和结果Lexile分数之间的绝对偏差。
   • 匹配率：结果Lexile分数是否在目标分数的±50范围内。
   • 方向准确性：结果Lexile分数是否朝着预期的方向（更容易或更难）变化。
   • BERTScores：评估内容保留的语义相似性。
   • 归一化编辑距离：评估源文本和结果文本之间的内容保留。
5. 结果分析：分析了不同模型在调整可读性和内容保留方面的表现，并识别了模型生成文本的倾向性，例如生成的文本通常比预期的更难。
6. 手动检查：对测试集中的10个样本进行了手动检查，以识别潜在问题，如信息误引入和编辑分布的不一致性。
7. 详细检查和讨论：对生成的文本进行了深入分析，讨论了使用这些输出作为教育材料可能存在的问题，并探讨了解决这些问题的方法。

这些实验的目的是为了创建分级文本生成任务的基准，并探索大型语言模型在这一任务上的潜力和局限性。通过这些实验，论文不仅展示了当前模型的性能，还为未来的研究提供了方向。

Q: 有什么可以进一步探索的点？

A: 根据论文的结论和讨论部分，以下是一些可以进一步探索的点：

1. 改进内容准确性：研究如何减少在文本简化或复杂化过程中引入的错误信息，特别是对于事实性内容，如科学和新闻文章。
2. 集成学习目标：探索如何在重写的文本中集成特定的教育目标，例如语法、词汇或知识点。
3. 保留关键信息：开发方法或工具，允许用户指定在文本重写过程中应保持不变的特定信息，如关键术语或重要句子。
4. 解决模型偏差：研究当前模型倾向于生成比原始文本更短的文本的原因，并探索如何减少这种偏差。
5. 提高编辑一致性：研究如何使模型在文本重写过程中进行更一致的编辑，避免出现某些段落未改变而其他段落大幅修改的情况。
6. 适应不同学习者的需求：研究如何根据不同学习者的具体需求定制文本难度，包括考虑年龄、背景知识和学习风格。
7. 开发更复杂的LLMs：考虑开发或改进LLMs，使其能够处理更复杂的文本重写任务，例如需要使用年龄适宜的类比或视觉辅助来解释复杂概念。
8. 用户界面设计：设计一个用户友好的界面，使用户能够轻松地指定文本中应保持不变的部分，并验证生成的文本是否满足这些标准。
9. 评估和改进模型的可解释性：提高模型在文本重写过程中的透明度和可解释性，帮助用户理解模型如何做出特定的编辑决策。
10. 跨学科研究：与其他学科的专家合作，例如教育学、心理学和认知科学，以更全面地理解文本难度对学习效果的影响。
11. 大规模实验和评估：在更大的数据集上进行实验，以验证模型性能的一致性，并在多样化的教育环境中评估生成文本的有效性。

这些探索点可以帮助研究者们提高分级文本生成任务的性能和质量，从而更好地服务于教育领域的需求。

Q: 总结一下论文的主要内容

A: 这篇论文的主要内容可以概括为以下几个要点：

1. 问题定义：论文提出了分级文本生成任务，目的是将教育材料改写成特定的可读性水平，同时保持原有内容的意义。
2. 研究背景：说明了学生从与他们阅读能力相匹配的阅读材料中学习更有效，因此需要为不同阅读水平的学生提供相应的教育内容。
3. 方法论：评估了三种大型语言模型（GPT-3.5、LLaMA-2 70B和Mixtral 8x7B）在零样本学习和少样本学习环境下的性能。
4. 数据集：构建了一个包含30,000对分级文本的并行数据集，用于训练和评估模型。
5. 评估指标：使用了平均绝对误差（MAE）、匹配率、方向准确性、BERTScores、语义相似性和归一化编辑距离等指标来评估模型的改写效果。
6. 实验结果：发现少样本学习显着提高了模型在可读性调整和信息保持方面的表现。LLaMA-2 70B在调整可读性方面表现最佳，而GPT-3.5在保持原文意义方面更为出色。
7. 问题识别：通过手动检查，发现了一些潜在问题，如信息误引入、编辑分布不均等。
8. 未来研究方向：基于实验结果和手动检查的发现，提出了未来研究的方向，包括提高内容准确性、集成学习目标、保留关键信息、解决模型偏差等。
9. 结论：论文强调了使用大型语言模型自动化教育内容创作的潜力和挑战，并指出了进一步研究的必要性。

整体而言，这篇论文为分级文本生成任务提供了一个基准，并展示了大型语言模型在教育领域的应用潜力，同时也指出了需要进一步解决的问题和挑战。

ChatGPT 的横空出世，其强大的能力最初得益于 2022 年 11 月发布的 GPT-3.5 模型 [25]，并在 2023 年 3 月升级到 GPT-4 [27]。OpenAI 表示，GPT-3.5 系列在 GPT-3 的基础上，通过指令微调、监督微调 (SFT) 和/或来自人类反馈的强化学习 (RLHF) [28] 进行了改进。2020 年发布的 GPT-3 [3] 在参数规模上实现了巨大飞跃，从 GPT-1 的 1.17 亿个参数和 GPT-2 的 15 亿个参数，提升至 1750 亿个参数。这种规模的提升使 GPT-3 具备了上下文学习和泛化能力，也推动了大型语言模型 (LLMs) 的兴起 [6; 41]。

受 GPT-3 的启发，我们提出了通用语言模型 (GLM) 架构 [11]，并于 2021 年开源了 GLM-10B 模型（参见图 1 中的 GLM 时间线）。从 2021 年底开始，我们开始预训练 GLM-130B [54]。目标是训练一个 1000 亿规模的模型，以匹配或超越 GPT-3（davinci），同时验证在这一规模上成功训练模型的技术，以及其他努力，如 OPT-175B [55] 和 BLOOM-176B [32]。我们于 2022 年 7 月完成了 GLM-130B 的 4000 亿个 token 的训练和评估，并在 8 月发布了模型和预训练细节 [54]。根据 2022 年 11 月的 HELM 数据，GLM-130B 在各个维度上都与 GPT-3（davinci）相当 [19]。

在此之后，我们开始对 GLM-130B 进行指令微调。后来，ChatGPT 进一步促使我们使用 SFT 和 RLHF 对基础模型进行对齐。我们从头开始创建和整理了提示-响应对，并执行了 SFT，同时开始研究如何有效地应用 RLHF。2023 年 3 月 14 日，对齐后的模型 ChatGLM-130B 在 https://chatglm.cn 上上线。此外，我们还在同一天开源了更小版本的 ChatGLM-6B [13]，它吸引了比预期多得多的关注。它的设计参数为 62 亿，旨在：1）促进预训练和后训练技术以及数据选择的快速迭代；2）使用 INT4 量化在消费级显卡上进行本地部署。从那时起，我们一直在快速探索和改进我们的预训练和对齐技术，每隔三个月就会发布第二代和第三代 ChatGLM 系列，这两代模型都是从头开始预训练的。

ChatGLM-6B 在大约一万亿个中英文语料库上进行预训练，上下文长度为 2048（2K），主要通过 SFT 进行补充。ChatGLM2-6B 于 6 月发布，在更多更好的数据上进行预训练和对齐，与前一代相比有了显著改进，包括 MMLU 提高了 23%，GSM8K 提高了 571%，BBH 提高了 60%。通过采用 FlashAttention 技术 [8]，其上下文长度扩展到 32K。此外，多查询注意力 (Multi-Query Attention) [34] 的整合使推理速度提高了 42%。更进一步，我们开发了第二代代码模型 CodeGeeX2-6B，它在另外 6000 亿个代码 token 上进行预训练。它在 HumanEval-X 的衡量下，展示了与第一代模型 CodeGeeX-13B [58] 相比，Pass@1 有所提高，在 Python 上提高了 57%，在 C++ 上提高了 71%，在 Java 上提高了 54%，在 JavaScript 上提高了 83%，在 Go 上提高了 56%。通过进一步实现更多样化的训练数据集、更充足的训练步骤和更优化的训练策略，ChatGLM3-6B 在语义、数学、推理、代码和知识方面超过了 42 个基准。从这一代开始，ChatGLM 还支持函数调用和代码解释器，以及复杂的任务 [9; 36; 51]。在这些开发过程中，我们还开发了参数规模为 15 亿、30 亿、120 亿、320 亿、660 亿和 1300 亿的模型，使我们能够验证我们的观察结果并建立我们自己的扩展定律。

吸取了所有经验教训，我们开始了 GLM-4 的训练。第一个截止检查点随后经历了多阶段的后训练过程（例如，SFT、RLHF、安全对齐），目前重点关注中英文。随后，它被开发成两个不同的版本：GLM-4 和 GLM-4 All Tools，两者都支持 128K 的上下文长度。从 2024 年 1 月 16 日起，GLM-4（0116）已通过 GLM-4 API 在 https://bigmodel.cn 上提供，GLM-4 All Tools 可通过网站 https://chatglm.cn 和支持创建自己的代理（GLMs）的移动应用程序访问。最新的模型是 GLM-4（0520）和 GLM-4-Air（0605），它们在预训练和对齐方面都有所升级。GLM-4-Air 在保持与 GLM-4（0116）相当的性能的同时，降低了延迟和推理成本。GLM-4 的评估是在各种语言基准上进行的。这些评估评估了 GLM-4 在英语中的通用能力、英语和中文的指令遵循能力、以及中文的对齐、长上下文和代理能力。

首先，在最常用的英语学术基准上，包括 MMLU、GSM8K、MATH、BBH、GPQA 和 HumanEval，GLM-4 0520 的性能与 GPT-4 0613 [27] 和 Gemini 1.5 Pro [40] 相当。例如，它在 MMLU 上的得分分别为 83.3、86.4 和 83.7。其次，根据 IFEval [61]，GLM-4 在提示和指令级别上的指令遵循能力与 GPT-4-Turbo 在英语和中文中的能力相当。第三，在中文语言对齐方面，GLM-4 在 AlignBench [21] 的八个维度上都超越了 GPT-4，并与 GPT-4-Turbo 相匹配。最后，在长上下文任务中，GLM-4（128K）模型的性能与 GPT-4 Turbo 和 Claude 3 Opus 相匹配，如 LongBench-Chat [1] 所测，分别为 87.3、87.2 和 87.7。

GLM-4 All Tools 模型专门针对更好地理解用户意图和自主选择最合适的工具来完成任务进行了对齐。例如，它可以以多轮方式通过网页浏览器访问在线信息，使用 Python 解释器解决数学问题，利用文本到图像模型生成图像，以及调用用户定义的函数。图 2 展示了 GLM-4 All Tools 使用网页浏览器和 Python 解释器来解决用户查询“搜索 2000 年至 2023 年的全球人口，然后计算年平均增长率”的示例。我们的第一手测试表明，它不仅与 GPT-4 All Tools 的能力相匹配，而且在常见任务中往往超过了它。

继我们三代开源 ChatGLM-6B 模型之后，我们还开源了 GLM-4-9B（128K 和 1M 上下文长度）模型。GLM-4-9B 在大约一万亿个多语言语料库上进行预训练，上下文长度为 8192（8K），并使用与 GLM-4（0520）相同的管道和数据进行后训练。在训练计算量较少的情况下，它超越了 Llama-3-8B [24]，并支持 GLM-4 中所有工具的功能。我们还提供了一个实验模型 GLM-4-9B-Chat-1M，其上下文长度为 100 万（1M）（约 200 万个汉字）。表 1 展示了三代 ChatGLM-6B 模型和 GLM-4-9B 的性能，说明了 ChatGLM 随着时间的推移而不断改进。

图 3 总结了从 GLM-130B 到 GLM-4 All Tools 的主要改进和功能。在这段旅程中，我们还为代码 LLMs（CodeGeeX [58]）以及用于图像理解的视觉语言模型（CogVLM [45] 和 CogAgent [16]）和文本到图像生成（CogView [10; 59]）的开源开发做出了贡献。开源模型和数据可以通过 https://github.com/THUDM 和 https://huggingface.co/THUDM 访问。

ChatGLM 技术

在本节中，我们将介绍我们在 ChatGLM 中采用和开发的预训练和后训练技术，包括模型架构、预训练数据、对齐和 All Tools。我们已经发布了详细的技术报告，介绍了我们用来达到 GLM-4 的每项主要技术的细节。

预训练数据

我们的预训练语料库由来自不同来源的多语言（主要是英语和中文）文档组成，包括网页、维基百科、书籍、代码和论文。数据处理流程主要包括三个阶段：去重、过滤和分词。去重阶段通过去除重复或相似的文档来提高数据多样性，包括精确去重和模糊去重。过滤阶段通过去除包含攻击性语言、占位符文本、源代码等噪音文档来提高数据质量。分词阶段将文本转换为一系列 token，以便进行进一步处理。预训练数据中的 token 数量直接影响模型训练速度。为了优化这方面，我们采用字节级字节对编码 (BPE) 算法 [33]，分别学习中文和多语言 token，并将它们与 tiktoken [26] 中 cl100k_base tokenizer 的 token 合并成一个统一的词汇表，大小为 150,000。在最终的训练集中，我们重新调整了不同来源的权重，以提高书籍和维基百科等高质量和教育性来源的比例。为此，预训练语料库包含大约一万亿个 token。

在 ChatGLM 开发的四代过程中，我们的发现与现有研究结果一致 [60]：数据质量和多样性对于构建有效的 LLMs 至关重要。尽管我们从经验教训中获得了经验和见解，但迄今为止，我们还没有找到可以指导数据收集、清理和选择过程的基本原则。

架构

GLM 家族的 LLMs 是基于 Transformer [43] 构建的。在 GLM-130B [54] 中，我们探索了各种选项来稳定其预训练，同时考虑了我们当时面临的硬件限制。具体来说，GLM-130B 利用 DeepNorm [44] 作为层归一化策略，并使用旋转位置编码 (RoPE) [38] 以及带有 GeLU [15] 激活函数的门控线性单元 (GLU) [35] 在 FFNs 中。在我们的探索过程中，我们研究了不同的策略来提高模型性能和推理效率。最新的 GLM-4 模型采用以下架构设计选择。

• 除了 QKV 之外没有偏差: 为了提高训练速度，我们去除了所有偏差项，除了注意力层的 Query、Key 和 Value (QKV) 中的偏差。这样做，我们观察到长度外推略有改善。
• RMSNorm 和 SwiGLU: 我们采用 RMSNorm 和 SwiGLU 分别替换 LayerNorm 和 ReLU。这两个策略被观察到具有更好的模型性能。
• 旋转位置嵌入 (RoPE): 我们将 RoPE 扩展到二维形式，以适应 GLM 中的二维位置编码。
• 分组查询注意力 (GQA): 我们用分组查询注意力 (GQA) 替换多头注意力 (MHA)，以减少推理过程中的 KV 缓存大小。由于 GQA 使用的参数少于 MHA，因此我们增加了 FFN 参数数量，以保持相同的模型大小，即设置 dffn 为隐藏大小的 10/3。

我们模型的上下文长度从 2K（ChatGLM）扩展到 32K（ChatGLM2 和 ChatGLM3），以及 128K 和 1M（GLM-4）。这种扩展不仅通过上下文扩展（位置编码扩展 [30; 5] 和长文本的持续训练 [47]）实现，而且通过长上下文对齐实现，使 GLM-4 能够有效地处理长上下文（参见 [1] 获取技术细节）。

对齐

预训练为 LLMs 打下了基础，而后训练 [28] 进一步细化了这些模型，使其与人类的偏好相一致，例如理解人类意图、遵循指令和促进多轮对话。对于 GLM-4，对齐主要通过监督微调 (SFT) 和来自人类反馈的强化学习 (RLHF) [17] 实现。在 SFT 中，我们发现真实的人类提示和交互，而不是基于模板或模型生成的响应，对于对齐质量至关重要。虽然 SFT 在很大程度上使基础模型与人类的偏好相一致，但 RLHF 可以进一步帮助缓解响应拒绝、安全、生成双语 token 的混合以及多轮一致性等问题。

对于第一代模型（ChatGLM-6B 和 ChatGLM-130B），提示-响应对主要由模型开发者标注。对于后来的模型，对齐数据是内部标注数据和从第三方获得的专有数据的组合，并经过相对严格的质量控制措施。与现有做法类似 [42]，标注者被指示从多个维度对模型响应进行评分，包括安全性、真实性、相关性、帮助性和人类偏好。

ChatGLM 技术

在 ChatGLM 的开发过程中，我们已经引入了并将在未来发布用于增强其性能的技术。

• LLMs 的涌现能力 [12]: 我们研究了预训练损失与下游任务性能之间的关系，发现对于相同的预训练损失，不同模型大小和训练 token 的 LLMs 会产生相同的下游性能。我们还发现，在某些任务（例如 MMLU 和 GSM8K）上，只有当预训练损失低于某个阈值时，性能才会超过随机机会。因此，我们将涌现能力重新定义为那些由预训练损失较低的模型表现出的能力 [12]。
• LongAlign [1]: 为了扩展 LLMs 的上下文窗口大小，我们提出了 LongAlign——一个用于长上下文对齐的综合方案。它使 GLM-4 能够处理长上下文文本（最多 128K 个 token），其性能与 Claude 2 和 GPT-4 Turbo（1106）相当。
• ChatGLM-Math [48]: 为了改进 LLMs 中的数学问题求解，我们引入了 ChatGLM-Math，它利用自我批评而不是外部模型或手动标注来进行数据选择。
• ChatGLM-RLHF [17]: 为了使 LLMs 与人类反馈相一致，我们引入了 ChatGLM-RLHF——我们在 LLMs 中应用 PPO 和 DPO 的实践。
• 自对比 [22]: 为了避免对昂贵的人类偏好反馈数据的需求，我们开发了一种无反馈对齐策略——自对比。它利用目标 LLM 本身来为其 RLHF 对齐自生成大量负样本。
• AgentTuning [53]: 为了提高 LLMs 的代理能力，我们开发了 AgentTurning 框架，以及包含代理与环境之间高质量交互轨迹的 AgentInstruct 指令微调数据集。
• APAR [20]: 为了提高 LLMs 对具有层次结构的响应的推理速度，我们提出了一种自动并行自动回归 (APAR) 生成方法。它利用指令微调来训练 LLMs 计划其（并行）生成过程并执行 APAR 生成。
• 基准: 我们还开发了几个开放的 LLM 基准，包括用于评估 LLMs 作为代理的 AgentBench [23]、用于评估 LLMs 的长上下文处理性能的 LongBench [2]、用于衡量 ChatGLM 与中文内容对齐质量的 AlignBench [1]、用于评估 HumanEval [4] 问题在 Python 以外的编程语言中的 HumanEval-X [58]，以及用于衡量模型解决实际编程任务能力的 NaturalCodeBench (NCB)。

GLM-4 All Tools

最新的 ChatGLM 模型是 GLM-4 和 GLM-4 All Tools，它们都使用上述技术进行训练和对齐。GLM-4 All Tools 是一个进一步对齐以支持智能代理和相关任务的模型版本。它可以自主理解用户意图，规划复杂的指令，并调用一个或多个工具（例如，网页浏览器、Python 解释器和文本到图像模型）来完成复杂的任务。图 4 展示了 GLM-4 All Tools 系统的整体流程。当用户发出一个复杂的请求时，模型会分析任务并逐步规划解决过程。如果它确定无法独立完成任务，它将依次调用一个或多个外部工具，利用它们的中间反馈和结果来帮助解决任务。

基于 GLM-4 的所有工具功能，我们还开发了 GLMs 应用程序平台，允许用户为特定任务创建和自定义自己的代理。GLMs 不仅支持嵌入式 Python 解释器、网页浏览器、文本到图像模型，还支持用户定义的函数、API 和外部知识库，以更有效地满足用户需求。

GLM-4 能力

我们从多个角度考察 GLM-4 模型的能力，包括在学术基准上的基础能力、代码问题解决能力、英语环境中的代理能力、以及指令遵循能力、中英文的长上下文能力，以及中文的对齐能力。如前所述，GLM-4 主要在中英文上进行预训练，并主要对齐到中文。在本节中，我们主要报告最新 GLM-4 版本（即 GLM-4（0520）和 GLM-4-Air（0605））的结果，因为 GLM-4（0520）在评估的基准上略好于其原始的 0116 版本。在评估期间，GLM-4 和 GLM-4-Air 都以 BFloat16 精度进行部署。

对于基线，我们展示了 GPT-4（0603）、GPT-4 Turbo（1106，2024-04-09）、Claude 2、Claude 3 Opus 和 Gemini 1.5 Pro 的结果，所有这些结果都是从相应的技术报告中提取或通过其公共 API 进行测试的。

总的来说，GLM-4 在标准基准、指令遵循、长上下文、代码问题解决和英语环境中的代理能力方面，与最先进的模型（GPT-4-Turbo、Gemini 1.5 Pro 和 Claude 3 Opus）相近。在中文对齐方面，它在各个领域（如基础语言能力、高级中文理解、专业知识和开放式问题）上都表现出强大的性能，与 SOTA 模型相比。总之，GLM-4 在中文语言任务方面处于领先地位。它还展示了与 GPT-4 和 Claude 3 Opus 在中文数学和逻辑推理能力方面相当的性能，尽管它落后于 GPT-4 Turbo。

3.1 学术基准评估

为了评估基础模型的总体性能，我们选择了六个常用的基准，涵盖知识、数学、推理、常识和编码：

• MMLU [14]: 从各种考试中收集的多项选择题，包括数学、历史、计算机科学等等。我们将所有答案提供给模型，并要求它选择答案的字母。
• GSM8K [7]: 8500 道小学数学应用题（测试集中有 1000 道），要求模型使用数学概念解决现实生活中的情境问题。我们为此基准使用链式思维提示 [46]。
• MATH: 12500 道具有挑战性的竞赛级数学题（测试集中有 5000 道）。我们为此基准使用链式思维提示 [46]。
• BBH [39]: 一套 23 个具有挑战性的 BIG-Bench [37] 任务。我们为此基准使用链式思维提示 [46]。
• GPQA [31]: 生物学、化学和物理学中的研究生级多项选择基准。
• HumanEval [4]: 一个编码基准，通过自动测试用例检查来衡量合成函数的正确性。

我们将 GLM-4 的性能与原始 GPT-4 [27] 进行比较。结果如表 2 所示。我们可以观察到，GLM-4 在 MMLU 上的准确率达到了 GPT-4 的 96.3%，并在其他基准上超过了 GPT-4。总的来说，GLM-4 的基础能力接近 GPT-4-Turbo 和 Claude 3 Opus。

3.2 指令遵循评估

我们使用最近引入的 IFEval 数据集 [61] 来评估 GLM-4 在遵循指令方面的熟练程度。该数据集包含 541 个提示，这些提示源于 25 个不同的指令，这些指令可以通过明确的标准进行验证（例如，“以以下内容结束你的电子邮件：P.S. 我很喜欢蛋糕”可以通过字符串匹配进行验证）。我们遵循 [61] 中概述的方法，以严格模式和宽松模式计算提示级别和指令级别的准确率。为了进一步评估模型在遵循中文指令方面的性能，我们将原始提示翻译成中文，省略了不适用于中文的指令（如大写字母），并调整评分脚本以适应中文数据。

3.3 对齐评估

AlignBench [21] 提供了一种自动的 LLMs-as-Judge 方法，用于对齐中文上下文中的 LLMs。它包含 683 个查询，涵盖 8 个不同的类别，并使用基于 GPT-4 的多维规则校准点式参考评分方法来判断模型响应。我们对 AlignBench-v1.1 进行评估，它更仔细地改进了参考生成质量，特别是通过将从网页收集的人工证据与知识要求问题的 URL 补充，这些问题占总查询的 66.5%。在这个版本上，几乎所有 LLMs 的得分都比之前在 AlignBench 上的得分低。

3.4 长上下文处理能力评估

为了获得 GLM-4 在长文本任务上的性能，我们在 LongBench-Chat [1] 上进行了评估，这是一个上下文长度从 10-100k 不等的基准集，涵盖了用户经常使用的大量长文本场景，例如文档问答、摘要和编码。为了更详细地比较 GLM-4 在不同语言上的性能，我们还根据语言对 LongBench-Chat 进行划分。这产生了两个不同的部分：中文和英文。我们分别提供了这两个部分的结果，提供了对 GLM-4 跨语言能力的细致概述。

关于具体的评估设置，我们根据 GPT-4 对每个模型的输出进行评分，在 LongBench-Chat 中采用少样本策略。此外，为了最大程度地减少得分差异并得出更可靠的统计结论，我们进行了重复评估。随后，我们计算这些多次评估的平均值，以确保最终的性能指标反映了对 GLM-4 在不同条件下的行为的全面了解。

表 5 展示了我们实验中获得的结果。可以清楚地观察到，GLM-4 在英语提示上的性能与 GPT-4 Turbo 和 Claude 3 Opus 相一致，并且它在中文提示上可以超过它们中的最佳者。

3.5 在现实世界用户提示上的编码评估

虽然 HumanEval [4] 已被广泛用于评估代码生成，但其大多数问题都可以归类为入门级算法。然而，在实践中，真实用户会提出用于生产目的的复杂问题，这些问题通常远远超出了 HumanEval 的范围。此外，之前的工作报道了 HumanEval 污染了训练数据 [27; 18; 50]，无论是它们自己的 LLM 还是其他 LLM，这使得 HumanEval 上的结果比以前不太可信。

因此，除了 HumanEval 之外，我们还在 NaturalCodeBench (NCB) [56] 上评估了 GLM-4，这是一个具有挑战性的双语编码基准，它源于自然用户提示，以反映现实世界编码任务的复杂性。结果如表 6 所示。它表明，GLM-4 在实际场景中的编码性能与 Claude 3 Opus 相近。虽然与 GPT-4 模型相比仍存在差距，但考虑到 GLM-4 的双语平衡性质，通过在接下来的迭代中采用更好的训练策略和数据整理，它在 NCB 上的性能还有很大的提升空间。

3.6 函数调用评估

为了评估 GLM 模型在函数调用方面的性能，我们在 Berkeley 函数调用排行榜 [49] 上进行了评估，这是一个包含 2k 个问题-函数-答案对的基准。该基准评估模型在调用函数方面的能力，分为三个类别：通过抽象语法树 (AST) 进行评估、通过执行 API 进行评估和相关性检测。第一类将模型输出的函数与函数文档和可能的答案进行比较，并进行 AST 分析。第二类通过执行生成的函数调用来检查响应的正确性。相关性检测评估模型识别不适合回答用户问题的函数的能力。结果如表 7 所示。我们可以观察到，GLM-4（0520）的函数调用能力与 GPT-4 Turbo（2024-04-09）相当，而 GLM-4-9B-Chat 显著超过 Llama-3-8B-Instruct。另一个观察结果是，总体准确率没有随着模型大小的增加而提高，而 GLM-4-9B-Chat 甚至可以超过 GLM-4-Air。另一方面，我们观察到，执行摘要的性能（评估现实世界 API 的执行结果）随着模型大小的增加而平稳提高。

3.7 代理能力评估

人们普遍观察到，LLMs 能够在各种环境和上下文中充当智能代理 [29; 52]，被称为 LLMs-as-Agents [23]。因此，我们使用 AgentBench [23] 对 GLM-4 以及其他比较 LLMs 进行了评估，这是一个全面的代理基准，用于评估各种实际环境中的文本型 LLMs，包括基于代码、基于游戏和基于网络的上下文。具体来说，我们对 8 个 AgentBench 环境中的 7 个进行了评估，除了数字卡牌游戏，因为它需要更长的时间与之交互。总分是使用 AgentBench [23] 中提供的原始每个数据集权重计算的。

3.8 All Tools 评估

GLM-4 进一步对齐以支持智能代理和用户在 https://chatglm.cn 上自配置的 GLMs 功能，由此产生的模型是 GLM-4 All Tools。如前所述，GLM-4 All Tools 可以通过自主理解用户意图、规划逐步指令以及调用多个工具（包括网页浏览器、Python 解释器和文本到图像模型（例如，CogView3 [59]））来完成复杂的任务。表 9 显示，GLM-4 All Tools（Web）在 Python 解释器上用于解决数学问题、浏览器上用于信息搜索方面，与 ChatGPT-4（Web）的性能相当。

4 安全和风险

我们致力于确保 GLM-4 作为一个安全、负责任和无偏见的模型运行。除了解决常见的伦理和公平问题外，我们还仔细评估并减轻模型在现实世界场景中可能对用户造成的潜在危害。

风险缓解

我们在预训练阶段仔细清理数据，通过删除包含敏感关键词的文本和来自预定义黑名单的网页。在对齐阶段，我们评估每个训练样本的安全性，并删除任何可能造成潜在风险的样本。在比较多个模型输出时，无害性也是偏好对齐的重要标准。

我们有一个红队，他们不断用棘手的问题挑战模型，这些问题往往会导致不安全的答案。我们收集了来自 GLM-4 的所有有害问题-答案对，并使用人工标注对其进行改进，以进一步进行模型对齐。

安全评估

我们在 SafetyBench [57] 数据集上评估了 GLM-4 模型，该数据集从 7 个维度评估每个模型的能力：伦理和道德（不道德行为）、非法活动（对法律的基本了解）、心理健康（对心理健康的不利影响）、攻击性（攻击性行为）、身体健康（可能造成身体伤害的危险行为）、隐私和财产（隐私泄露或财产损失）、不公平性和偏见。我们对 SafetyBench 的中文子集评估了不同的模型，该子集是通过删除可能被屏蔽的敏感性很高的问题创建的，以减轻不同 API 安全策略的干扰。

表 10 显示了 GLM-4 和 SOTA 模型的安全结果。在大多数维度上，GLM-4（0520）表现出具有竞争力的安全性能，总体上它与 Claude 3 Opus 实现了相当的性能。GLM-4 在身体健康维度上略微落后于 GPT-4 家族的模型，这需要关于物理世界的强大常识知识，以避免潜在风险。我们已经投入了更多努力，朝着这个方向发展一个更强大和更安全的 GLM 模型。

5 结论

在本报告中，我们介绍了从 GLM-130B 到 GLM-4（All Tools）的 ChatGLM 大型语言模型家族。在过去一年半的时间里，我们从第一手经验中在理解大型语言模型的各个方面取得了巨大进展。随着每一代模型的开发，团队已经学习并应用了更有效、更高效的模型预训练和对齐策略。最新的 ChatGLM 模型——GLM-4（0116、0520）、GLM-4-Air（0605）和 GLM-4 All Tools——在理解和执行复杂任务方面取得了显著进步，通过自主使用外部工具和函数来实现。这些 GLM-4 模型在性能上与最先进的模型（如 GPT-4 Turbo、Claude 3 Opus 和 Gemini 1.5 Pro）相当，在某些情况下甚至超过了它们，特别是在处理与中文相关的任务时。此外，我们致力于通过开源模型权重和在这段旅程中开发的技术来促进 LLMs 的可访问性和安全性。我们的开源模型，包括语言、代码和视觉模型，仅在 2023 年就吸引了超过 1000 万次下载。目前，我们正在使用迄今为止学到的所有知识来开发更强大的模型。未来，我们将继续通过开源来普及尖端的 LLM 技术，并将模型能力的边界推向让机器像人类一样思考的目标。

致谢

我们要感谢所有数据标注者、基础设施运营人员、合作者和合作伙伴，以及 Zhipu AI 和清华大学未在报告中明确提及的所有为 ChatGLM 提供支持、反馈和贡献的人员。我们还要感谢 Zhipu AI 的张宇轩和贾伟，以及 Hugging Face、ModelScope、WiseModel 等团队在 GLM 家族模型的开源工作中提供的帮助。

参考文献

[1] LongAlign: A Comprehensive Recipe for Long Context Alignment. https://arxiv.org/abs/2404.05640

[2] LongBench: A Benchmark for Evaluating Long Context Handling Abilities of LLMs.

---

Q: 这篇论文试图解决什么问题？

A: 这篇论文介绍了ChatGLM，这是一个不断发展的大型语言模型家族，包括从GLM-130B到GLM-4的各个版本。论文的主要目标是展示这个家族中最新的GLM-4系列模型，包括GLM-4、GLM-4-Air和GLM-4-9B，这些模型利用了之前三代ChatGLM的经验教训和洞察力进行训练。这些模型主要针对中文和英文使用进行了高质量的对齐，通过多阶段的后训练过程实现，包括监督式微调和从人类反馈中学习。

论文试图解决的问题包括：

1. 大型语言模型的持续改进：通过不断的技术迭代和训练方法的优化，提高模型的性能。
2. 多语言支持：尽管主要关注中文和英文，但模型也支持其他语言，以满足不同用户的需求。
3. 对齐人类意图：通过后训练过程，提高模型理解用户意图和执行指令的能力。
4. 长文本处理：通过扩展模型的上下文长度，提升模型处理长文本的能力。
5. 实用功能集成：GLM-4 All Tools模型能够理解用户意图并自主决定何时以及使用哪些工具来有效完成任务，如网页浏览器、Python解释器、文本到图像模型和用户定义的函数。

总的来说，论文的目标是展示ChatGLM家族在大型语言模型领域的最新进展，并证明其在多种任务和能力上与当前最先进模型的竞争力。

Q: 有哪些相关研究？

A: 论文中提到了多个与大型语言模型（LLMs）相关的研究工作，以下是一些主要的相关研究：

1. GPT-3系列：由OpenAI开发，包括GPT-3.5和GPT-4，这些模型通过引入指令调整、监督式微调（SFT）和/或从人类反馈中学习的强化学习（RLHF）来改进性能。
2. OPT175B 和 BLOOM-176B：这些是其他研究团队开发的大规模模型，与GLM-130B一样，旨在探索和验证在大规模数据集上训练模型的技术。
3. Transformer架构：这是许多现代语言模型的基础，包括GLM系列。它引入了自注意力机制来处理串行数据。
4. FlashAttention：一种提高注意力机制效率的技术，由Dao et al. (2022) 提出。
5. CodeGeeX：一个专注于代码生成的预训练模型，由Zheng et al. (2023) 开发。
6. CogVLM 和 CogAgent：这些是视觉语言模型，分别用于图像理解和基于GUI的代理任务。
7. CogView：一个文本到图像的生成模型，由Ding et al. (2021) 提出。
8. MMLU：一个多语言、多任务的语言理解评估基准，由Hendrycks et al. (2021) 开发。
9. GSM8K、MATH、BBH、GPQA 和 HumanEval：这些是用于评估模型在特定领域（如数学问题解答、编程等）性能的基准测试。
10. AlignBench：一个评估模型在中文上下文中对齐能力的基准测试，由Liu et al. (2023) 提出。
11. LongBench：一个评估模型处理长文本能力的基准测试，由Bai et al. (2023) 开发。
12. AgentBench：一个评估模型作为智能代理在各种环境中的表现的基准测试，由Liu et al. (2023) 提出。

这些研究为GLM系列模型的开发提供了技术背景和评估标准，同时也展示了大型语言模型领域的最新进展。

Q: 论文如何解决这个问题？

A: 论文通过以下方法解决大型语言模型的开发和优化问题：

1. 多代模型开发：从GLM-130B到GLM-4，每一代模型都在前一代的基础上进行改进，利用之前的经验教训和洞察力。
2. 预训练和后训练技术：使用高质量的数据集进行预训练，并采用多阶段后训练过程，包括监督式微调（SFT）和从人类反馈中学习的强化学习（RLHF），以提高模型与人类意图的对齐。
3. 模型架构优化：在GLM-4中采用了无偏置（除Query、Key、Value外）、RMSNorm、SwiGLU、二维Rotary Positional Embedding（RoPE）和Group Query Attention（GQA）等技术来提升模型性能和推理效率。
4. 上下文长度扩展：通过持续训练和长上下文对齐技术，如LongAlign，扩展模型的上下文长度，使GLM-4能够有效处理长文本。
5. 智能工具集成：GLM-4 All Tools模型能够理解用户意图，并自主选择使用适当的工具（如Web浏览器、Python解释器、文本到图像模型等）来完成任务。
6. 性能评估：在多种语言基准上评估GLM-4的性能，包括学术基准、指令跟随、长文本处理、编程问题解决和代理能力。
7. 安全性和风险评估：通过数据清洗、安全评估和风险缓解策略，确保GLM-4作为安全、负责任和无偏见的模型运行。
8. 开放模型和数据：通过开源模型权重、技术和数据，促进大型语言模型技术的普及和安全。
9. 持续迭代和改进：基于当前的模型和技术，继续开发更强大的模型，以推动机器模拟人类思维的边界。

通过这些方法，论文展示了ChatGLM家族在大型语言模型领域的进步，并证明了其在多种任务上与现有最先进模型的竞争力。

Q: 论文做了哪些实验？

A: 论文中进行了一系列实验来评估GLM-4模型的性能，包括以下几个方面：

1. 学术基准测试：使用MMLU、GSM8K、MATH、BBH、GPQA和HumanEval等标准学术基准来评估模型的一般性能。
2. 指令跟随能力评估：使用IFEval数据集来评估GLM-4在遵循指令方面的能力，包括在英语和中文环境中的表现。
3. 中文对齐评估：使用AlignBench来评估GLM-4在中文上下文中的对齐能力，包括数学逻辑、语言理解和专业知识等多个维度。
4. 长文本处理能力评估：使用LongBench-Chat来评估GLM-4处理长文本的能力，包括中文和英文的长文本场景。
5. 实际编程问题解决：使用NaturalCodeBench来评估GLM-4在实际编程问题上的表现，包括Python和Java两种编程语言。
6. 函数调用能力评估：使用Berkeley Function Call Leaderboard来评估GLM-4在函数调用方面的能力。
7. 代理能力评估：使用AgentBench来评估GLM-4作为智能代理在多种环境中的表现，包括基于代码、游戏和网络的环境。
8. 安全性评估：使用SafetyBench来评估GLM-4在安全性方面的性能，包括伦理道德、非法活动、心理健康等多个维度。
9. GLM-4 All Tools功能评估：评估GLM-4 All Tools模型在集成多种工具（如Web浏览器、Python解释器和文本到图像模型）后完成复杂任务的能力。

这些实验结果表明GLM-4在多个方面与现有的最先进模型（如GPT-4 Turbo、Claude 3 Opus和Gemini 1.5 Pro）具有竞争力，特别是在处理与中文相关的任务时。此外，实验还揭示了GLM-4在某些领域（如代码相关问题解决）中存在的改进空间。

Q: 有什么可以进一步探索的点？

A: 尽管论文中已经展示了许多关于GLM-4模型的实验和评估，但仍有一些领域可以进一步探索：

1. 模型泛化能力：研究GLM-4在未见过的数据或领域上的表现，特别是在低资源语言或特定行业术语上。
2. 模型解释性：提高模型的可解释性，帮助用户理解其决策过程，特别是在复杂任务或推理任务中。
3. 多模态能力：虽然当前模型主要关注文本，但可以探索将视觉、音频等多模态数据集成到模型中。
4. 鲁棒性和错误分析：深入分析模型在特定任务或数据集上失败的原因，以改进模型的鲁棒性。
5. 交互式学习：研究模型如何在与用户的交互中学习并改进其性能，特别是在开放式对话系统中。
6. 安全性和隐私保护：进一步研究如何保护用户的隐私并确保模型的输出不会引起安全问题。
7. 模型压缩和加速：探索模型压缩技术，以减少模型的大小和提高推理速度，使其更适合在资源受限的环境中使用。
8. 跨语言能力：研究模型在处理跨语言问题时的能力，例如代码中的自然语言注释或多语言文档的翻译和理解。
9. 长期记忆和上下文保持：研究如何改进模型在长时间对话或复杂任务中保持上下文信息的能力。
10. 可扩展性：探索如何将模型扩展到更大的规模，以及这种扩展如何影响其性能和效率。
11. 公平性和偏见减少：持续监测和减少模型可能表现出的偏见，确保其对所有用户都是公平的。
12. 实际应用场景：将模型应用于实际问题，如教育、医疗咨询、客户服务等领域，并评估其实际效果。

这些探索点可以帮助研究者和开发者更好地理解GLM-4模型的潜力和局限性，并指导未来的研究方向。

Q: 总结一下论文的主要内容

A: 这篇论文主要介绍了ChatGLM，一个由GLM-130B到GLM-4的不断进化的大型语言模型家族。以下是论文的主要内容概述：

1. 模型介绍：ChatGLM是一系列大型语言模型，包括GLM-4、GLM-4-Air和GLM-4-9B，它们在中文和英文上进行了高质量的对齐。
2. 预训练数据：使用多语言文档进行预训练，包括网页、维基百科、书籍、代码和论文等，通过去重、过滤和分词等数据处理步骤。
3. 模型架构：GLM-4采用了无偏置（除QKV外）、RMSNorm、SwiGLU、二维RoPE和Group Query Attention (GQA)等架构设计。
4. 后训练对齐：通过监督式微调（SFT）和强化学习（RLHF）等后训练技术，进一步与人类偏好对齐。
5. 性能评估：GLM-4在多个学术基准上与GPT-4等模型进行了比较，显示出在某些领域的优势，特别是在中文对齐方面。
6. GLM-4 All Tools：一个特别对齐的模型版本，支持智能代理和相关任务，能够自主选择使用适当的工具来完成任务。
7. 技术贡献：论文还介绍了一些用于提升LLM性能的技术，如LongAlign、ChatGLM-Math、ChatGLM-RLHF、Self-Contrast、AgentTuning和APAR等。
8. 安全性和风险：讨论了模型的安全性和风险评估，以及在数据预处理和对齐阶段采取的风险缓解措施。
9. 开放模型和数据：论文强调了模型和数据的开放性，包括在Hugging Face上的下载量和通过GitHub访问的模型。
10. 未来工作：论文最后讨论了未来的研究方向，包括开发更强大的模型和推动LLM技术的发展。

总的来说，这篇论文展示了ChatGLM家族在大型语言模型领域的最新进展，并证明了其在多种任务上与现有最先进模型的竞争力。同时，论文也强调了模型的开放性和安全性，以及未来的研究方向。

大型语言模型 (LLM) 在自然语言处理 (NLP) 领域展现出非凡的能力，能够解决各种任务。然而，完全微调 LLM 成本高昂，难以在边缘设备上实现。为了解决这个问题，参数高效微调 (PEFT) 技术应运而生，其中一种名为低秩适应 (LoRA) 的方法备受关注。

LoRA 假设预训练权重的变化存在于低秩空间中，因此在模型的冻结主路径中添加两个可训练的低秩适配器，称为投影矩阵 A (PMA) 和投影矩阵 B (PMB)。这种方法虽然减少了可训练参数数量，但随着模型嵌入维度的增加，LoRA 的可训练参数需求也会增加，导致计算成本高昂。此外，LoRA 的反向更新需要存储高维中间激活和优化器状态，对 GPU 内存峰值提出了很高的要求。

为了解决这些问题，本文介绍了一种名为 LaMDA 的新方法，它利用低维适应来显著减少可训练参数和 GPU 内存峰值。LaMDA 在适应路径中冻结第一个投影矩阵 (PMA)，同时引入一个低维可训练方阵，从而大幅减少可训练参数和 GPU 内存峰值。LaMDA 在早期微调阶段逐渐冻结第二个投影矩阵 (PMB)，进一步降低与权重更新相关的计算成本，提高参数效率。

此外，本文还介绍了 LaMDA 的增强版 LaMDA++，它通过对预训练模型权重的规范化频谱分析，为 LoRA 路径引入了“轻量级”自适应秩分配。

LaMDA：低维适配器的魅力

LaMDA 的核心是低维适配器 (LDA)，它是一个 r 维方阵，其中 r 远小于模型的嵌入维度 d。LaMDA 将 PMA 冻结，而 LDA 始终可训练，PMB 则根据奇异值的相对大小逐渐冻结。这种设计使得可训练参数与 d 无关，并且用于反向传播的激活存储在 r 维空间中，从而显著减少可训练参数、激活和优化器状态内存。

LaMDA 的优势：

• 减少可训练参数： LaMDA 的可训练参数数量仅为 LoRA 的 r2，与模型的嵌入维度 d 无关，有效地限制了参数数量，降低了过拟合风险，提高了模型的泛化能力。
• 降低计算成本： 由于可训练参数数量减少，LaMDA 的反向传播计算量也大幅降低，减少了梯度更新和优化器状态计算，减轻了微调的整体计算和优化器存储开销。
• 节省内存： LaMDA 将激活存储在 r 维空间中，显著减少了激活内存使用，从而可以微调更大的模型或使用更大的批次大小。

LaMDA++：自适应秩分配的优化

LaMDA++ 在 LaMDA 的基础上，引入了自适应秩分配机制，根据预训练模型权重的能量得分，为不同层分配不同的秩。

LaMDA++ 的优势：

• 更有效地利用参数预算： LaMDA++ 通过分析预训练模型权重的能量得分，将更多的秩分配给对秩减少影响较小的层，而将更少的秩分配给对秩减少影响较大的层，从而更有效地利用参数预算。
• 简化实现和使用： LaMDA++ 采用“轻量级”静态分析方法，避免了动态调整秩带来的复杂性和计算开销，简化了实现和使用。

实验结果

本文对 LaMDA 和 LaMDA++ 在自然语言理解 (NLU)、自然语言生成 (NLG) 和推理任务上进行了评估，结果表明：

• NLU 任务： LaMDA 在 GLUE 基准测试中取得了与 LoRA 相当的性能，但可训练参数数量减少了 17.7 倍。LaMDA++ 则取得了最优性能，参数数量略有增加。
• NLG 任务： LaMDA 在 XSUM 和 CNN/DailyMail 数据集上取得了与 LoRA 相当的性能，但可训练参数数量减少了 10 倍。LaMDA++ 在 XSUM 数据集上超越了 LoRA，在 CNN/DailyMail 数据集上与 LoRA 性能相当。
• 推理任务： LaMDA 和 LaMDA++ 在 GSM8K 和 Wikitext-2 数据集上都超越了 LoRA。LaMDA 在 Commonsense170K 数据集上取得了比 LoRA 更高的平均准确率，同时可训练参数数量减少了 11.5 倍。

结论

LaMDA 是一种新颖的 LLM 微调框架，它利用低维适配器，显著减少了可训练参数数量，节省了激活内存，并通过自适应秩分配进一步优化了性能。LaMDA 和 LaMDA++ 能够有效地微调更大的模型，为模型适应提供了一种高效且可扩展的方法。

参考文献

• Hu, Y., et al. (2022). Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685.
• Kopiczko, R., et al. (2024). Vera: Parameter-efficient fine-tuning by projecting to a low-dimensional subspace. arXiv preprint arXiv:2310.17678.
• Pan, X., et al. (2024a). AdaLoRA: Adaptive low-rank adaptation of large language models. arXiv preprint arXiv:2305.11720.
• Liu, Z., et al. (2024). AFLoRA: Adaptive frozen low-rank adaptation for efficient large language model fine-tuning. arXiv preprint arXiv:2310.16125.
• Meng, Z., et al. (2024). On the importance of adapter initialization for parameter-efficient fine-tuning of large language models. arXiv preprint arXiv:2310.17463.

---

Q: 这篇论文试图解决什么问题？

A: 这篇论文介绍了一种名为LaMDA（Large Model Fine-tuning via Spectrally Decomposed Low-Dimensional Adaptation）的新方法，旨在解决大型语言模型（LLMs）微调过程中的两个主要问题：

1. 训练参数需求随着模型嵌入维度的增加而增加：传统的低秩适应（LoRA）方法在微调大型语言模型时，虽然减少了可训练参数的数量，但当模型的嵌入维度增大时，所需的训练参数数量仍然可能很大。
2. 高计算成本和GPU内存占用：LoRA方法在反向更新过程中需要存储高维中间激活和优化器状态，这导致GPU内存需求高，尤其在模型参数过多的情况下，容易造成过度拟合和灾难性遗忘。

为了解决这些问题，LaMDA采用了低维适应技术，通过冻结第一投影矩阵（PMA）并引入一个低维可训练的方阵，显着减少了可训练参数和GPU内存占用。此外，LaMDA在微调的早期阶段逐步冻结第二投影矩阵（PMB），进一步降低与权重更新相关的计算成本，提高参数效率。论文还提出了LaMDA++，一种增强版的方法，通过对方阵进行“轻量级”的自适应秩分配，利用预训练模型权重的归一化谱分析来优化LoRA路径。

总的来说，LaMDA和LaMDA++旨在提供一种更为高效和可扩展的方式来微调大型语言模型，减少所需的训练参数和内存占用，同时保持或提高模型性能。

Q: 有哪些相关研究？

A: 论文中提到了几种与LaMDA相关的研究和技术，主要包括以下几种：

1. LoRA (Low-rank Adaptation) (Hu et al., 2022): 一种流行的微调大型语言模型的方法，通过添加两个可训练的低秩适配器来减少训练参数的数量。
2. VERA (Vector-based Random Matrix Adaptation) (Kopiczko et al., 2024): 一种不同的方法，通过随机初始化和冻结PMA和PMB，专注于微调两个特征转换矢量。
3. AFLoRA (Adaptive Freezing LoRA) (Liu et al., 2024): 为了解决VERA的计算效率问题而提出的方法，但仍然存在高激活存储开销。
4. LISA (Layerwise Importance Sampling for Memory-efficient Fine-tuning) (Pan et al., 2024b): 一种针对内存效率优化的微调方法。
5. AdaLoRA: LoRA的一个变种，通过动态学习适配器的秩来提高微调预算的利用效率。
6. DeBERTa-V3 (He et al., 2023): 用于自然语言理解任务的编码器模型。
7. BART-Large (Lewis et al., 2020): 用于文本摘要和自然语言生成任务的编码器-解码器模型。
8. LLaMA2-7B (Touvron et al., 2023b): 用于复杂推理任务的解码器模型。
9. Transformer-based models (Vaswani et al., 2017): 论文中还讨论了基于Transformer的模型的背景，这些模型通常由多头自注意力（MHSA）子块和前馈网络（FFN）组成。

这些研究和技术为LaMDA提供了理论基础和比较基准，使得LaMDA能够在减少训练参数和降低GPU内存占用方面取得显着进步。

Q: 论文如何解决这个问题？

A: 论文通过提出LaMDA（Large Model Fine-tuning via Spectrally Decomposed Low-Dimensional Adaptation）框架解决了大型语言模型（LLMs）微调过程中遇到的高参数需求和高计算成本问题。以下是LaMDA解决这些问题的关键步骤和方法：

1. 低维适配器（Low-Dimensional Adapter, LDA）：
   • LaMDA引入了一个低维的可训练方阵LDA，该方阵在r维空间中，与模型的嵌入维度d相比，r通常小得多。
2. 冻结投影矩阵（Projection Matrix Freezing）：
   • 在微调过程中，LaMDA冻结了第一投影矩阵（PMA），并只训练LDA，从而显着减少了可训练参数的数量。
3. 逐步冻结第二投影矩阵（Gradual Freezing of the Second Projection Matrix, PMB）：
   • LaMDA在微调的早期阶段逐步冻结PMB，这有助于在保持LaMDA优势的同时提高模型对复杂任务的适应性。
4. LaMDA++（增强版LaMDA）：
   • 利用预训练模型权重的归一化谱分析，为每层的LDA自适应地分配秩，从而实现更优的参数分布。
5. 初始化策略：
   • LaMDA使用奇异值分解（SVD）对预训练权重进行分解，并用对应的奇异矢量初始化PMA和PMB，这有助于在微调开始时近似原始权重。
6. 内存和计算效率：
   • 由于LDA的使用和PMA的冻结，LaMDA在反向传播过程中减少了激活存储的需求，从而降低了GPU内存的使用。
7. 实验验证：
   • 论文通过在多种任务和不同大小的LLMs上进行实验，验证了LaMDA与现有方法相比，在减少参数更新数量和降低GPU内存使用方面的优势。
8. 性能对比：
   • 实验结果显示，LaMDA在保持或提高性能的同时，相比于现有方法，需要更少的参数更新和更低的GPU内存占用。

通过这些方法，LaMDA在减少训练参数、降低内存占用和计算成本方面取得了显着的改进，同时保持了或提高了模型性能。

Q: 论文做了哪些实验？

A: 论文中进行了一系列的实验来评估LaMDA和LaMDA++方法的性能。以下是实验的主要方面：

1. 模型和数据集：实验涵盖了不同类型的模型，包括编码器（DeBERTa-V3）、编码器-解码器（BART-large）和解码器（LLaMA2-7B）模型。使用了多个数据集，如GLUE基准测试用于自然语言理解（NLU），XSUM和CNN/DailyMail用于文本摘要（NLG），以及GSM8K、Wikitext-2和Commonsense170K用于复杂推理任务。
2. 微调方法比较：LaMDA与全参数微调（Full FT）、LoRA、LoRA-FA、AdaLoRA、VERA、AFLoRA和LISA等现有的参数高效微调（PEFT）技术进行了比较。
3. 性能指标：根据不同任务的性质，使用了不同的性能指标，例如GLUE基准上的准确率、文本摘要任务上的ROUGE分数、复杂推理任务上的准确率以及Wikitext-2上的困惑度（Perplexity）。
4. 可训练参数数量：实验报告了LaMDA和LaMDA++与基线方法相比在减少可训练参数数量方面的效果。
5. GPU内存使用情况：通过在不同批处理大小下对BART-large模型进行微调，测量了不同微调方法在峰值GPU内存使用上的差异。
6. LaMDA++的秩分配策略：通过分析预训练模型权重的归一化能量得分，评估了LaMDA++的自适应秩分配策略的有效性。
7. 初始化选择的影响：研究了不同初始化方法（如使用最大奇异值对应的奇异矢量、随机初始化等）对LaMDA性能的影响。
8. 逐步冻结PMB的迭代次数：研究了在微调过程中逐步冻结PMB的迭代次数对LaMDA性能的影响。
9. LaMDA++排名的影响：评估了LaMDA++根据能量得分对层进行排序并分配秩的策略对训练过程和性能的影响。
10. 常识推理任务：在多个常识推理数据集上评估了LaMDA的性能，包括BoolQ、PIQA、SIQA、HellaSwag、WinoGrande、ARC-e、ARC-c和OBQA。

这些实验结果表明，LaMDA和LaMDA++在减少可训练参数数量和降低GPU内存需求的同时，能够与或超越现有方法的性能。

Q: 有什么可以进一步探索的点？

A: 根据论文的讨论和结论部分，以下是一些可以进一步探索的点：

1. 在更大模型上的测试：论文中提到，他们测试的最大模型是LLaMA2-7B。由于时间限制，他们未能在更大的模型上测试LaMDA。未来的工作可以在更大的模型上评估LaMDA的可扩展性和有效性。
2. 在指令遵循任务上的应用：LaMDA尚未在指令遵循任务上进行测试。评估LaMDA在这些特定任务上的性能对于完全理解其潜力和多功能性至关重要。
3. 应用于视觉-语言模型：论文没有探索LaMDA方法在视觉-语言模型上的应用。考虑到多模态学习的重要性，将LaMDA应用于这类模型是一个值得探索的方向。
4. 改进的秩分配策略：尽管LaMDA++采用了基于能量得分的秩分配策略，但可能存在更精细或更动态的秩分配方法，这些方法可以进一步优化模型性能和参数效率。
5. 长期维护和灾难性遗忘问题：在持续微调过程中，研究LaMDA如何处理长期维护问题和灾难性遗忘问题，以及如何改进以减少这些问题的影响。
6. 不同领域的适应性：研究LaMDA在不同领域（如医疗、法律等专业领域）的适应性，以及是否需要针对特定领域进行调整。
7. 与其他微调技术的比较：与其他新兴的微调技术进行比较，以评估LaMDA在不同方面（如速度、内存效率、易用性等）的相对优势和局限性。
8. 模型解释性和可理解性：提高LaMDA微调过程中模型的解释性和可理解性，帮助研究人员和实践者更好地理解模型的决策过程。
9. 跨语言评估：评估LaMDA在不同语言上的微调效果，以及它如何处理语言之间的差异。
10. 环境影响评估：研究LaMDA在减少计算资源需求的同时，对环境影响（如能源消耗和碳足迹）的潜在影响。

这些探索点可以帮助研究者更深入地理解LaMDA的潜力，并推动大型语言模型微调技术的发展。

Q: 总结一下论文的主要内容

A: 这篇论文介绍了LaMDA，一种用于大型语言模型（LLMs）微调的新方法。以下是论文的主要内容总结：

1. 问题识别：论文首先指出了现有微调大型语言模型方法（如LoRA）存在的问题，包括随着模型尺寸增加而增加的参数需求，以及高计算成本和GPU内存占用。
2. LaMDA方法：提出了LaMDA方法，它通过使用低维适配器（LDA）和逐步冻结第二投影矩阵（PMB）来减少可训练参数和GPU内存占用。
3. LaMDA++：介绍了LaMDA的增强版LaMDA++，它通过归一化谱分析自适应地为不同层分配秩，以优化参数分布。
4. 实验设置：论文详细描述了实验的设置，包括使用的不同模型（DeBERTa-V3、BART-large、LLaMA2-7B）和数据集（GLUE、XSUM、CNN/DailyMail、GSM8K、Wikitext-2等）。
5. 性能比较：展示了LaMDA和LaMDA++与现有微调方法（包括Full FT、LoRA、AdaLoRA、VERA、AFLoRA和LISA）的性能比较，证明了LaMDA在减少参数数量和降低GPU内存使用方面的优势。
6. 内存和计算效率：通过实验数据，论文展示了LaMDA在不同批处理大小下对BART-large模型微调时的内存效率。
7. 初始化和秩分配策略：研究了不同的初始化方法和LaMDA++的秩分配策略对性能的影响。
8. 逐步冻结PMB的影响：分析了逐步冻结PMB的迭代次数对LaMDA性能的影响。
9. 常识推理任务：在多个常识推理数据集上评估了LaMDA的性能，并与LoRA进行了比较。
10. 结论和局限性：论文总结了LaMDA的主要贡献，并指出了研究的局限性，如未在更大的模型和指令遵循任务上进行测试，以及未探索在视觉-语言模型上的应用。
11. 未来工作：提出了未来可能的研究方向，包括在更大模型上的测试、指令遵循任务、视觉-语言模型应用等。

论文的代码将在GitHub上公开，以供研究社区使用和进一步研究。

近年来，人工智能领域取得了令人瞩目的进展，其中大型语言模型（LLM）的出现被认为是通向通用人工智能（AGI）的关键一步。LLM 拥有强大的语言理解和生成能力，为构建能够感知环境、做出决策并执行行动的智能体提供了坚实的基础。本文将深入探讨 LLM 驱动的智能体，从其构建、应用到社会模拟等方面展开论述。

1. 智能体的诞生：LLM 驱动的智能体构建

LLM 驱动的智能体通常由三个主要部分组成：大脑、感知和行动。

1.1 大脑：以 LLM 为核心

LLM 是智能体的大脑，赋予其强大的语言能力，使其能够理解和生成自然语言。

1.1.1 自然语言交互

LLM 在自然语言交互方面展现出卓越的能力，包括：

• 高质量生成： LLM 可以生成流畅、连贯且富有创意的文本，例如，在 Towards End-to-End Embodied Decision Making via Multi-modal Large Language Model: Explorations with GPT4-Vision and Beyond 中，研究者利用 LLM 构建了 PCA-EVAL，一个用于评估基于 LLM 的端到端方法和工具使用方法的基准测试平台。
• 深度理解： LLM 能够理解文本的语义、情感和意图，例如，在 Clever Hans or Neural Theory of Mind? Stress Testing Social Reasoning in Large Language Models. 中，研究者发现 LLM 在一定程度上具备心智理论能力，但这种能力并不稳健。

1.1.2 知识

LLM 的知识储备是其强大能力的基石，主要来源包括：

• 预训练模型： LLM 通过在海量文本数据上进行预训练，学习了丰富的语言知识，例如，Learning Distributed Representations of Sentences from Unlabelled Data 中提出的词嵌入模型，为 LLM 提供了基础的语言知识。
• 语言知识： LLM 掌握了语言的语法、语义和词汇知识，例如，Probing Pre-trained Language Models for Semantic Attributes and their Values 研究了 LLM 对语义属性和值的理解能力。
• 常识知识： LLM 具备一定程度的常识推理能力，例如，Language Models of Code are Few-Shot Commonsense Learners 发现代码语言模型可以进行少样本常识学习。
• 可操作知识： LLM 可以将知识转化为可执行的行动，例如，Large language models in medicine 讨论了 LLM 在医疗领域的应用，可以帮助医生诊断和治疗疾病。

1.1.3 内存

LLM 的内存能力决定了其记忆和检索信息的能力。

• 内存能力： LLM 的内存能力可以通过以下方法提升：
  • 提高 Transformer 的长度限制： 例如，MemGPT: Towards LLMs as Operating Systems 提出了 MemGPT，一个将 LLM 作为操作系统使用的框架，可以处理更长的文本序列。
  • 记忆摘要： 例如，Walking Down the Memory Maze: Beyond Context Limit through Interactive Reading 通过交互式阅读来扩展 LLM 的上下文长度。
  • 使用向量或数据结构压缩记忆： 例如，ChatDB: Augmenting LLMs with Databases as Their Symbolic Memory 将数据库作为 LLM 的符号记忆，扩展了其记忆能力。
• 记忆检索： LLM 需要能够有效地从记忆中检索相关信息，例如，Memory Sandbox: Transparent and Interactive Memory Management for Conversational Agents 提出了一种透明且交互式的内存管理方法，用于对话智能体。

1.1.4 推理与规划

LLM 的推理和规划能力是其解决复杂问题、制定行动计划的关键。

• 推理： LLM 可以进行逻辑推理和归纳推理，例如，Training Large Language Models for Reasoning through Reverse Curriculum Reinforcement Learning 提出了一种基于反向课程强化学习的 LLM 推理训练方法。
• 规划： LLM 可以根据目标制定行动计划，包括：
  • 计划制定： 例如，Tree of Thoughts: Deliberate Problem Solving with Large Language Models 提出了一种基于树结构的 LLM 规划方法。
  • 计划反思： 例如，Agent-Pro: Learning to Evolve via Policy-Level Reflection and Optimization 提出了一种基于策略级反思和优化的 LLM 智能体进化方法。

1.1.5 可迁移性和泛化性

LLM 的可迁移性和泛化性决定了其在不同任务和场景下的适应能力。

• 未见任务泛化： LLM 可以将已学知识迁移到新的任务，例如，AgentTuning: Enabling Generalized Agent Abilities for LLMs 提出了一种用于赋予 LLM 泛化能力的训练方法。
• 上下文学习： LLM 可以通过少量示例快速学习新任务，例如，Language Models are Few-Shot Learners 展示了 LLM 的少样本学习能力。
• 持续学习： LLM 可以不断学习新知识，避免遗忘旧知识，例如，Voyager: An Open-Ended Embodied Agent with Large Language Models 展示了 LLM 驱动的终身学习智能体在 Minecraft 中的应用。

1.2 感知：多模态输入

LLM 驱动的智能体可以通过多模态感知，获取更丰富的信息。

1.2.1 视觉

LLM 可以理解和生成图像信息，例如，Images Speak in Images: A Generalist Painter for In-Context Visual Learning 提出了一个用于上下文视觉学习的通用模型 Painter。

1.2.2 音频

LLM 可以理解和生成音频信息，例如，Neural Codec Language Models are Zero-Shot Text to Speech Synthesizers 训练了一个神经编解码语言模型 VALL-E，具备上下文学习能力。

1.3 行动：扩展行动空间

LLM 驱动的智能体可以通过工具使用和具身行动，扩展其行动能力。

1.3.1 工具使用

LLM 可以使用外部工具来完成任务，例如，ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs 提出了一种通用的工具使用框架 ToolLLM，可以帮助 LLM 使用各种 API。

1.3.2 具身行动

LLM 可以控制机器人等具身智能体，在物理环境中执行任务，例如，PaLM-E: An Embodied Multimodal Language Model 提出了一种具身多模态语言模型 PaLM-E，可以进行具身行动。

2. 智能体在实践中：LLM 驱动的智能体应用

LLM 驱动的智能体在各个领域展现出巨大的应用潜力。

2.1 单个智能体的通用能力

2.1.1 任务导向部署

LLM 驱动的智能体可以用于完成各种特定任务，例如：

• 网络场景： WebArena: A Realistic Web Environment for Building Autonomous Agents 提供了一个真实的网络环境，用于构建自主智能体。
• 生活场景： InterAct: Exploring the Potentials of ChatGPT as a Cooperative Agent 探讨了 ChatGPT 作为合作智能体的潜力。

2.1.2 创新导向部署

LLM 驱动的智能体可以用于推动创新，例如：

• 科学研究： Emergent autonomous scientific research capabilities of large language models 探讨了 LLM 在科学研究中的应用。
• 艺术创作： Generative Agents: Interactive Simulacra of Human Behavior 展示了 LLM 在艺术创作中的应用。

2.1.3 生命周期导向部署

LLM 驱动的智能体可以用于模拟生物的生命周期，例如：

• 游戏场景： Plan4MC: Skill Reinforcement Learning and Planning for Open-World Minecraft Tasks 展示了 LLM 驱动的智能体在 Minecraft 中的应用。
• 社会模拟： S³: Social-network Simulation System with Large Language Model-Empowered Agents 提出了一种基于 LLM 的社会网络模拟系统。

2.2 多个智能体的协调潜力

2.2.1 合作交互以实现互补

LLM 驱动的智能体可以协同合作，发挥各自的优势，例如：

• 无序合作： RoCo: Dialectic Multi-Robot Collaboration with Large Language Models 提出了一种基于 LLM 的多机器人协作框架。
• 有序合作： AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework 提出了一种基于多智能体对话的 LLM 应用框架。

2.2.2 对抗交互以实现进步

LLM 驱动的智能体可以通过对抗交互，提升各自的能力，例如：

• 辩论： Improving Factuality and Reasoning in Language Models through Multiagent Debate 展示了 LLM 通过辩论来提升事实性和推理能力。
• 博弈： Mastering the Game of No-Press Diplomacy via Human-Regularized Reinforcement Learning and Planning 展示了 LLM 在外交博弈中的应用。

2.3 人机交互

2.3.1 指导者-执行者模式

LLM 驱动的智能体可以作为人类的助手，执行指令，例如：

• 教育： Math Agents: Computational Infrastructure, Mathematical Embedding, and Genomics 展示了 LLM 在数学教育中的应用。
• 医疗： HuatuoGPT, towards Taming Language Model to Be a Doctor 展示了 LLM 在医疗诊断和治疗中的应用。

2.3.2 平等伙伴模式

LLM 驱动的智能体可以作为人类的伙伴，进行平等的交流和合作，例如：

• 情感交流： SAPIEN: Affective Virtual Agents Powered by Large Language Models 展示了 LLM 在情感交流中的应用。
• 共同参与： Human-level play in the game of Diplomacy by combining language models with strategic reasoning 展示了 LLM 在外交博弈中的应用。

3. 智能体社会：从个体到群体

LLM 驱动的智能体可以形成社会，模拟人类社会的行为和现象。

3.1 LLM 驱动的智能体的行为和个性

3.1.1 社会行为

• 个体行为： Reflexion: Language Agents with Verbal Reinforcement Learning 展示了 LLM 驱动的智能体在学习和决策过程中的个体行为。
• 群体行为： AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors in Agents 展示了 LLM 驱动的智能体在群体中的行为模式。

3.1.2 个性

• 认知： Machine Psychology: Investigating Emergent Capabilities and Behavior in Large Language Models Using Psychological Methods 探讨了 LLM 的认知能力。
• 情感： Emotional Intelligence of Large Language Models 探讨了 LLM 的情感智能。
• 性格： Do LLMs Possess a Personality? Making the MBTI Test an Amazing Evaluation for Large Language Models 探讨了 LLM 的性格特征。

3.2 智能体社会环境

3.2.1 文本环境

LLM 驱动的智能体可以在文本环境中进行交互，例如，Hoodwinked: Deception and Cooperation in a Text-Based Game for Language Models 展示了 LLM 在文本游戏中的应用。

3.2.2 虚拟沙盒环境

LLM 驱动的智能体可以在虚拟沙盒环境中进行模拟，例如，Generative Agents: Interactive Simulacra of Human Behavior 展示了 LLM 在虚拟环境中的应用。

3.2.3 物理环境

LLM 驱动的智能体可以控制机器人等具身智能体，在物理环境中进行交互，例如，RoboAgent: Generalization and Efficiency in Robot Manipulation via Semantic Augmentations and Action Chunking 展示了 LLM 在机器人控制中的应用。

3.3 基于 LLM 的智能体社会模拟

LLM 驱动的智能体可以用于模拟人类社会，例如：

• 社会规范的出现： Emergence of Social Norms in Large Language Model-based Agent Societies 研究了 LLM 驱动的智能体社会中社会规范的形成。
• 社会现象的模拟： Epidemic Modeling with Generative Agents 展示了 LLM 驱动的智能体在流行病模拟中的应用。

4. 未来展望：机遇与挑战并存

LLM 驱动的智能体正处于快速发展阶段，其强大的语言能力、知识储备、推理规划能力以及可迁移性和泛化性，使其在各种领域展现出巨大潜力。然而，我们也必须清醒地认识到，这项技术的发展并非一帆风顺，还面临着许多挑战和风险。

4.1 互相促进：LLM 与智能体研究的双向赋能

LLM 研究为智能体研究提供了强大的基础模型，例如，LLM 可以帮助智能体进行决策、规划和行动，并有效地处理未见任务。另一方面，智能体研究也为 LLM 研究提出了新的挑战和方向，例如，如何让 LLM 更好地理解环境、学习新的技能以及进行更有效的社会交互。

4.2 评价体系：多维评估，确保智能体安全可靠

评估 LLM 驱动的智能体是一个复杂的过程，需要考虑多个维度：

• 效用： 评估智能体完成任务的效率和成功率，例如，AgentBench: Evaluating LLMs as Agents 提供了一个用于评估 LLM 作为智能体的能力的基准测试框架。
• 社会性： 评估智能体与人类和其他智能体的交互能力，例如，ChatEval: Towards Better LLM-based Evaluators through Multi-Agent Debate 提出了一种基于多智能体辩论的 LLM 评估方法。
• 价值观： 评估智能体的道德和伦理水平，确保其行为符合人类社会价值观，例如，Constitutional AI: harmlessness from AI feedback 提出了一种基于 AI 反馈的无害性训练方法。
• 持续进化： 评估智能体不断学习和适应的能力，例如，Voyager: An Open-Ended Embodied Agent with Large Language Models 展示了 LLM 驱动的终身学习智能体在 Minecraft 中的应用。

4.3 安全与信任：防范风险，构建可信赖的智能体

LLM 驱动的智能体在应用过程中存在着许多潜在风险，例如：

• 对抗性攻击： LLM 容易受到对抗性攻击，例如，PromptAttack: Prompt-based Attack for Language Models via Gradient Search 提出了一种基于提示的 LLM 攻击方法。
• 可信度问题： LLM 可能存在幻觉问题，例如，Self-Contradictory Hallucinations of Large Language Models: Evaluation, Detection and Mitigation 探讨了 LLM 的自我矛盾幻觉问题。
• 其他风险： LLM 驱动的智能体可能被恶意利用，例如，The malicious use of artificial intelligence: Forecasting, prevention, and mitigation 讨论了人工智能的恶意使用问题。

为了降低风险，我们需要采取措施，例如：

• 增强鲁棒性： 通过对抗性训练等方法，提升 LLM 的鲁棒性。
• 提高可信度： 通过思维链等方法，增强 LLM 的可解释性和可信度。
• 规范使用： 制定相关政策和标准，规范 LLM 驱动的智能体的使用。

4.4 规模化：构建更复杂、更真实的智能体社会

随着智能体数量的增加，我们可以构建更复杂、更真实的智能体社会，例如：

• 提高任务效率： 例如，AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework 展示了 LLM 驱动的智能体在多智能体协作中的应用。
• 增强社会模拟： 例如，S³: Social-network Simulation System with Large Language Model-Empowered Agents 提出了一种基于 LLM 的社会网络模拟系统。

然而，规模化也带来了新的挑战，例如：

• 计算负担： 智能体数量的增加会带来巨大的计算负担。
• 协调难度： 协调大量智能体进行有效的合作和交流会非常困难。
• 信息失真： 智能体数量的增加可能导致信息失真和传播问题。

4.5 开放问题：探索未知，展望未来

LLM 驱动的智能体领域还有许多开放问题需要进一步研究，例如：

• 通向 AGI 的道路： LLM 驱动的智能体是否能成为通向 AGI 的道路？
• 从虚拟到现实： 如何将 LLM 驱动的智能体从虚拟环境迁移到真实的物理环境？
• 群体智能： 如何利用 LLM 驱动的智能体社会来探索群体智能的奥秘？
• 代理即服务： 如何将 LLM 驱动的智能体作为服务提供给用户？

5. 结语

LLM 驱动的智能体正在改变着我们对人工智能的理解，也为我们带来了前所未有的机遇和挑战。未来，我们期待着 LLM 驱动的智能体能够在更多领域发挥作用，为人类社会带来更大的福祉。

参考文献

[1] The Rise and Potential of Large Language Model Based Agents: A Survey. Zhiheng Xi et al. (2023). https://arxiv.org/abs/2309.07864

[2] LLM-Agent-Paper-List. https://github.com/WooooDyy/LLM-Agent-Paper-List

致谢

感谢复旦大学自然语言处理团队（FudanNLP）的辛勤付出，为我们带来了这篇精彩的综述论文。

在学习新技术时，一份好的教程可以事半功倍。MetaGPT 的教学助手角色，可以帮助你根据简单的描述，自动生成技术教程文档。

教学助手的功能

教学助手可以根据用户提供的单句描述，生成一份技术教程文档，并支持自定义语言。

设计理念

教学助手的设计思路是：

1. 使用大型语言模型 (LLM) 生成教程的大纲。
2. 根据二级标题将大纲分解成多个部分。
3. 针对每个部分，根据标题生成详细内容。
4. 最后将标题和内容拼接起来。

使用分段的方式，可以解决 LLM 模型处理长文本的限制。

代码实现

角色定义

定义教学助手角色类，继承自 Role 基类，并重写 __init__ 初始化方法。__init__ 方法必须包含 name、profile、goal 和 constraints 参数。第一行代码使用 super().__init__(name, profile, goal, constraints) 调用父类的构造函数，初始化 Role。使用 self.set_actions([WriteDirectory(language=language)]) 添加初始动作和状态。这里，最初添加了写目录动作。此外，还可以定义自定义参数；这里添加了 language 参数，用于支持自定义语言。使用 self._set_react_mode(react_mode="by_order") 将 set_actions 中的动作执行顺序设置为顺序执行。

class TutorialAssistant(Role):
    """教学助手，输入一句话生成一份标记格式的教程文档。

    Args:
        name: 角色名称。
        profile: 角色简介。
        goal: 角色目标。
        constraints: 角色的约束或要求。
        language: 生成教程文档的语言。
    """

    def __init__(
        self,
        name: str = "Stitch",
        profile: str = "教学助手",
        goal: str = "生成教程文档",
        constraints: str = "严格遵循 Markdown 语法，布局整洁规范",
        language: str = "Chinese",
    ):
        super().__init__(name, profile, goal, constraints)
        self.set_actions([WriteDirectory(language=language)])
        self.topic = ""
        self.main_title = ""
        self.total_content = ""
        self.language = language
        self._set_react_mode(react_mode="by_order")

重写 react 方法

重写 react 方法。使用 await super().react() 调用 Role 基类的 react 方法。根据 __init__ 方法中设置的 react_mode="by_order"，按顺序执行 states 中的每个动作。这里重写的目的是在完成所有动作后执行最终操作，即：将拼接后的教程内容写入 markdown 文件。

async def react(self) -> Message:
    msg = await super().react()
    root_path = TUTORIAL_PATH / datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    await File.write(root_path, f"{self.main_title}.md", self.total_content.encode('utf-8'))
    return msg

重写 _act 方法

_act 方法负责执行动作。使用 todo = self.rc.todo 从上下文中获取下一个要执行的动作，然后执行动作的 run 方法。这里，它首先通过 WriteDirectory 获取教程目录结构，然后对目录进行分块，为每个块生成一个 WriteContent 动作，并初始化新添加的动作。这里再次调用 await super().react() 是为了从头开始执行所有新添加的 WriteContent 动作。每个动作的结果用于生成一个 Message(content=resp, role=self.profile) 消息，该消息可以放置在上下文记忆 self.rc.memory 中。该角色不需要存储。

async def _act(self) -> Message:
    todo = self.rc.todo
    if type(todo) is WriteDirectory:
        msg = self.rc.memory.get(k=1)[0]
        self.topic = msg.content
        resp = await todo.run(topic=self.topic)
        logger.info(resp)
        await self._handle_directory(resp)
        return await super().react()
    resp = await todo.run(topic=self.topic)
    logger.info(resp)
    if self.total_content != "":
        self.total_content += "\n\n\n"
    self.total_content += resp
    return Message(content=resp, role=self.profile)

async def _handle_directory(self, titles: Dict) -> Message:
    """处理教程文档的目录。

    Args:
        titles: 包含标题和目录结构的字典，
                例如 {"title": "xxx", "directory": [{"dir 1": ["sub dir 1", "sub dir 2"]}]}

    Returns:
        包含目录信息的 Message。
    """
    self.main_title = titles.get("title")
    directory = f"{self.main_title}\n"
    self.total_content += f"# {self.main_title}"
    actions = list()
    for first_dir in titles.get("directory"):
        actions.append(WriteContent(language=self.language, directory=first_dir))
        key = list(first_dir.keys())[0]
        directory += f"- {key}\n"
        for second_dir in first_dir[key]:
            directory += f"  - {second_dir}\n"
    self.set_actions(actions)

动作定义

定义动作，每个动作对应一个类对象。继承自 Action 基类，并重写 __init__ 初始化方法。__init__ 方法包含 name 参数。第一行代码使用 super().__init__(name, *args, **kwargs) 调用父类的构造函数，初始化动作。这里，使用 args 和 kwargs 将其他参数传递给父类构造函数，例如 context 和 llm。

#!/usr/bin/env python3
# _*_ coding: utf-8 _*_
"""
@Time    : 2023/9/4 15:40:40
@Author  : Stitch-z
@File    : tutorial_assistant.py
@Describe : Actions of the tutorial assistant, including writing directories and document content.
"""

from typing import Dict

from metagpt.actions import Action
from metagpt.prompts.tutorial_assistant import DIRECTORY_PROMPT, CONTENT_PROMPT
from metagpt.utils.common import OutputParser


class WriteDirectory(Action):
    """写教程目录的动作类。

    Args:
        name: 动作名称。
        language: 输出语言，默认值为 "Chinese"。
    """

    def __init__(self, name: str = "", language: str = "Chinese", *args, **kwargs):
        super().__init__(name, *args, **kwargs)
        self.language = language

重写 run 方法

run 方法是动作执行的主要函数，使用 self._aask(prompt=prompt) 方法查询 LLM 模型。

async def run(self, topic: str, *args, **kwargs) -> Dict:
    """执行动作，根据主题生成教程目录。

    Args:
        topic: 教程主题。

    Returns:
        教程目录信息，包括 {"title": "xxx", "directory": [{"dir 1": ["sub dir 1", "sub dir 2"]}]}。
    """
    prompt = DIRECTORY_PROMPT.format(topic=topic, language=self.language)
    resp = await self._aask(prompt=prompt)
    return OutputParser.extract_struct(resp, dict)

其他动作的编写类似：

class WriteContent(Action):
    """写教程内容的动作类。

    Args:
        name: 动作名称。
        directory: 要写入的内容。
        language: 输出语言，默认值为 "Chinese"。
    """

    def __init__(self, name: str = "", directory: str = "", language: str = "Chinese", *args, **kwargs):
        super().__init__(name, *args, **kwargs)
        self.language = language
        self.directory = directory

    async def run(self, topic: str, *args, **kwargs) -> str:
        """执行动作，根据目录和主题写入文档内容。

        Args:
            topic: 教程主题。

        Returns:
            写入的教程内容。
        """
        prompt = CONTENT_PROMPT.format(topic=topic, language=self.language, directory=self.directory)
        return await self._aask(prompt=prompt)

角色执行结果

输入示例

• MySQL 教程
• Redis 教程
• Hive 教程

执行命令示例

提供相应的执行命令示例。

执行结果

生成的教程文档位于项目的 /data/tutorial_docx 目录中。

注意：

该角色目前不支持互联网搜索功能。内容生成依赖于 LLM 大模型训练的数据。

总结

MetaGPT 的教学助手角色可以帮助你快速生成技术教程文档，并支持自定义语言。它可以节省你大量时间和精力，让你专注于更重要的工作。

更多学习资源

• MetaGPT 文档：了解更多关于 MetaGPT 的信息。
• MetaGPT Github：查看 MetaGPT 的源代码和示例。
• MetaGPT 论文：深入了解 MetaGPT 的技术细节。

在信息爆炸的时代，获取准确可靠的信息并将其整理成简洁易懂的报告，是一项非常重要的技能。MetaGPT 的研究员角色，可以帮助你完成这项任务。

研究员的角色

MetaGPT 的研究员角色可以模拟人类在互联网上进行研究的过程。它能够：

• 分析研究问题，将其分解成多个适合搜索引擎查询的子问题。
• 使用搜索引擎搜索子问题，并根据标题、原始 URL、摘要等信息评估每个结果的相关性和可靠性。
• 决定是否需要进一步浏览网页。
• 点击需要进一步探索的网页，评估内容是否对研究问题有帮助，提取相关信息并记录。
• 将所有记录的相关信息汇总，并撰写一份解决研究问题的报告。

研究员的架构

MetaGPT 的研究员角色包含三个主要动作：

• CollectLinks: 从搜索引擎收集链接。
• WebBrowseAndSummarize: 浏览网页并提供摘要。
• ConductResearch: 进行研究并生成研究报告。

动作定义

CollectLinks

CollectLinks 动作用于搜索互联网以获取相关问题并检索 URL 地址列表。由于用户输入的问题可能不直接适合搜索引擎查询，CollectLinks 动作首先将用户的问题分解成多个适合搜索的子问题。然后，它使用搜索引擎进行搜索。

实现使用了 tools 模块中的 SearchEngine，支持通过 serpapi/google/serper/ddg 进行搜索。实现细节可以在 metagpt/actions/research.py 文件中找到，以下是对 CollectLinks.run 方法的基本解释：

class CollectLinks(Action):

    async def run(
        self,
        topic: str,
        decomposition_nums: int = 4,
        url_per_query: int = 4,
        system_text: str | None = None,
    ) -> dict[str, list[str]]:
        """运行动作以收集链接。

        Args:
            topic: 研究主题。
            decomposition_nums: 要生成的搜索问题的数量。
            url_per_query: 每个搜索问题要收集的 URL 数量。
            system_text: 系统文本。

        Returns:
            一个字典，包含搜索问题作为键，收集的 URL 作为值。
        """
        system_text = system_text if system_text else RESEARCH_TOPIC_SYSTEM.format(topic=topic)
        # 将研究问题分解成多个子问题
        keywords = await self._aask(SEARCH_TOPIC_PROMPT, [system_text])
        try:
            keywords = OutputParser.extract_struct(keywords, list)
            keywords = parse_obj_as(list[str], keywords)
        except Exception as e:
            logger.exception(f"fail to get keywords related to the research topic \"{topic}\" for {e}")
            keywords = [topic]

        # 使用搜索引擎搜索子问题
        results = await asyncio.gather(*(self.search_engine.run(i, as_string=False) for i in keywords))

        # 浏览搜索引擎结果，并过滤掉与研究问题无关的结果
        def gen_msg():
            while True:
                search_results = "\n".join(f"#### Keyword: {i}\n Search Result: {j}\n" for (i, j) in zip(keywords, results))
                prompt = SUMMARIZE_SEARCH_PROMPT.format(decomposition_nums=decomposition_nums, search_results=search_results)
                yield prompt
                remove = max(results, key=len)
                remove.pop()
                if len(remove) == 0:
                    break
        prompt = reduce_message_length(gen_msg(), self.llm.model, system_text, CONFIG.max_tokens_rsp)
        logger.debug(prompt)
        queries = await self._aask(prompt, [system_text])
        try:
            queries = OutputParser.extract_struct(queries, list)
            queries = parse_obj_as(list[str], queries)
        except Exception as e:
            logger.exception(f"fail to break down the research question due to {e}")
            queries = keywords
        ret = {}

        # 对搜索结果进行排序，并获取 TopK URL
        for query in queries:
            ret[query] = await self._search_and_rank_urls(topic, query, url_per_query)
        return ret

WebBrowseAndSummarize

WebBrowseAndSummarize 动作负责浏览网页并对其内容进行摘要。MetaGPT 在 tools 模块中提供了 WebBrowserEngine，它支持通过 playwright/selenium 进行网页浏览。WebBrowseAndSummarize 动作使用 WebBrowserEngine 进行网页浏览。

实现细节可以在 metagpt/actions/research.py 文件中找到，以下是对 WebBrowseAndSummarize.run 方法的基本解释：

class WebBrowseAndSummarize(Action):
    async def run(
        self,
        url: str,
        *urls: str,
        query: str,
        system_text: str = RESEARCH_BASE_SYSTEM,
    ) -> dict[str, str]:
        """运行动作以浏览网页并提供摘要。

        Args:
            url: 要浏览的主要 URL。
            urls: 要浏览的其他 URL。
            query: 研究问题。
            system_text: 系统文本。

        Returns:
            一个字典，包含 URL 作为键，其摘要作为值。
        """
        # 网页浏览和内容提取
        contents = await self.web_browser_engine.run(url, *urls)
        if not urls:
            contents = [contents]

        # 网页内容摘要
        summaries = {}
        prompt_template = WEB_BROWSE_AND_SUMMARIZE_PROMPT.format(query=query, content="{}")
        for u, content in zip([url, *urls], contents):
            content = content.inner_text
            chunk_summaries = []
            for prompt in generate_prompt_chunk(content, prompt_template, self.llm.model, system_text, CONFIG.max_tokens_rsp):
                logger.debug(prompt)
                summary = await self._aask(prompt, [system_text])
                if summary == "Not relevant.":
                    continue
                chunk_summaries.append(summary)

            if not chunk_summaries:
                summaries[u] = None
                continue

            if len(chunk_summaries) == 1:
                summaries[u] = chunk_summaries[0]
                continue

            content = "\n".join(chunk_summaries)
            prompt = WEB_BROWSE_AND_SUMMARIZE_PROMPT.format(query=query, content=content)
            summary = await self._aask(prompt, [system_text])
            summaries[u] = summary
        return summaries

ConductResearch

ConductResearch 动作负责撰写研究报告。它使用 WebBrowseAndSummarize 动作的摘要数据作为上下文，然后生成研究报告。

实现细节可以在 metagpt/actions/research.py 文件中找到，以下是对 ConductResearch.run 方法的基本解释：

class ConductResearch(Action):
    async def run(
        self,
        topic: str,
        content: str,
        system_text: str = RESEARCH_BASE_SYSTEM,
    ) -> str:
        """运行动作以进行研究并生成研究报告。

        Args:
            topic: 研究主题。
            content: 研究内容。
            system_text: 系统文本。

        Returns:
            生成的 research report。
        """
        prompt = CONDUCT_RESEARCH_PROMPT.format(topic=topic, content=content)
        logger.debug(prompt)
        self.llm.auto_max_tokens = True
        return await self._aask(prompt, [system_text])

研究员角色

研究员角色将 CollectLinks、WebBrowseAndSummarize 和 ConductResearch 动作结合在一起，实现了搜索互联网并汇总报告的功能。因此，在初始化时需要使用 set_actions 方法将这三个动作添加到角色中。由于这些动作按照 CollectLinks -> WebBrowseAndSummarize -> ConductResearch 的顺序执行，因此需要在 react/_act 方法中定义这些动作的执行逻辑。

实现细节可以在 metagpt/roles/researcher.py 文件中找到，以下是对 Researcher 类的基本解释：

class Researcher(Role):
    def __init__(
        self,
        name: str = "David",
        profile: str = "Researcher",
        goal: str = "Gather information and conduct research",
        constraints: str = "Ensure accuracy and relevance of information",
        language: str = "en-us",
        **kwargs,
    ):
        super().__init__(name, profile, goal, constraints, **kwargs)

        # 添加 `CollectLinks`、`WebBrowseAndSummarize` 和 `ConductResearch` 动作
        self.set_actions([CollectLinks(name), WebBrowseAndSummarize(name), ConductResearch(name)])

        # 设置按顺序执行
        self._set_react_mode(react_mode="by_order")
        self.language = language
        if language not in ("en-us", "zh-cn"):
            logger.warning(f"The language `{language}` has not been tested, it may not work.")

    async def _act(self) -> Message:
        logger.info(f"{self._setting}: ready to {self.rc.todo}")
        todo = self.rc.todo
        msg = self.rc.memory.get(k=1)[0]
        if isinstance(msg.instruct_content, Report):
            instruct_content = msg.instruct_content
            topic = instruct_content.topic
        else:
            topic = msg.content

        research_system_text = get_research_system_text(topic, self.language)
        # 搜索互联网并检索 URL 信息
        if isinstance(todo, CollectLinks):
            links = await todo.run(topic, 4, 4)
            ret = Message(content="", instruct_content=Report(topic=topic, links=links), role=self.profile, cause_by=todo)
        # 浏览网页并对其内容进行摘要
        elif isinstance(todo, WebBrowseAndSummarize):
            links = instruct_content.links
            todos = (todo.run(*url, query=query, system_text=research_system_text) for (query, url) in links.items())
            summaries = await asyncio.gather(*todos)
            summaries = list((url, summary) for i in summaries for (url, summary) in i.items() if summary)
            ret = Message(content="", instruct_content=Report(topic=topic, summaries=summaries), role=self.profile, cause_by=todo)
        # 生成 research report
        else:
            summaries = instruct_content.summaries
            summary_text = "\n---\n".join(f"url: {url}\nsummary: {summary}" for (url, summary) in summaries)
            content = await self.rc.todo.run(topic, summary_text, system_text=research_system_text)
            ret = Message(content="", instruct_content=Report(topic=topic, content=content), role=self.profile, cause_by=type(self.rc.todo))
        self.rc.memory.add(ret)
        return ret

    async def react(self) -> Message:
        msg = await super().react()
        report = msg.instruct_content
        # 输出 report
        self.write_report(report.topic, report.content)
        return msg

使用说明

依赖和配置

研究员角色依赖于 SearchEngine 和 WebBrowserEngine。以下是安装和配置这些组件的简要说明。

SearchEngine

支持 serpapi/google/serper/ddg 搜索引擎。它们的区别如下：

名称	默认引擎	附加依赖包	安装
serpapi	√		pip install metagpt[search-google]
google	×	google-api-python-client	pip install metagpt[search-google]
serper	×
ddg	×	duckduckgo-search	pip install metagpt[search-ddg]

配置：

• serpapi:
  • search.engine: 设置为 serpapi
  • search.api_key: 从 https://serpapi.com/ 获取
  • search.params: 要传递给搜索引擎的附加参数，例如：
• google:
  • search.engine: 设置为 google
  • search.api_key: 从 https://console.cloud.google.com/apis/credentials 获取
  • search.cse_id: 从 https://programmablesearchengine.google.com/controlpanel/create 获取
• serper:
  • search.engine: 设置为 serper
  • search.api_key: 从 https://serper.dev/ 获取
• ddg:
  • search.engine: 设置为 ddg

WebBrowserEngine

支持 playwright/selenium 引擎。要使用它们，必须安装额外的依赖项。它们的区别如下：

名称	默认引擎	附加依赖包	安装	异步	支持的平台
playwright	√	playwright, beautifulsoup4	pip install metagpt[playwright]	Native	部分支持的平台
selenium	×	selenium, webdriver_manager, beautifulsoup4	pip install metagpt[selenium]	线程池	几乎所有平台

配置：

• playwright:
  • browser.engine: 设置为 playwright
  • browser.browser_type: 支持 chromium/firefox/webkit，默认值为 chromium。更多信息： Playwright BrowserTypes
• selenium:
  • browser.engine: 设置为 selenium
  • browser.browser_type: 支持 chrome/firefox/edge/ie，默认值为 chrome。更多信息： Selenium BrowserTypes

运行示例和结果

metagpt.roles.researcher 模块提供了一个命令行界面，用于执行研究员的功能。以下是一个示例：

python3 -m metagpt.roles.researcher "tensorflow vs. pytorch"

日志输出：log.txt
报告输出：dataiku vs. datarobot.md

总结

MetaGPT 的研究员角色可以帮助你快速高效地从互联网上搜集信息并撰写研究报告。它可以节省你大量时间和精力，让你专注于更重要的工作。

更多学习资源

• MetaGPT 文档：了解更多关于 MetaGPT 的信息。
• MetaGPT Github：查看 MetaGPT 的源代码和示例。
• MetaGPT 论文：深入了解 MetaGPT 的技术细节。

在之前的教程中，我们学习了如何整合开源 LLM，让你的 AI 团队更强大。但你是否想过，如何让团队中的每个成员都拥有独特的个性和能力？

MetaGPT 允许你为不同的角色和动作指定不同的 LLM，让你的 AI 团队更加灵活和真实。

个性化配置

MetaGPT 提供了两种方式来定制 LLM 配置：

1. 默认配置： MetaGPT 提供了一些默认配置，你可以直接使用。
2. 自定义配置： 你可以在 ~/.metagpt 目录中创建自定义配置文件。

示例：

假设你想为 GPT-4、GPT-4-turbo 和 GPT-3.5-turbo 创建配置：

from metagpt.config2 import Config

# 示例配置：gpt-4、gpt-4-turbo 和 gpt-3.5-turbo
gpt4 = Config.from_home("gpt-4.yaml")  # 从 `~/.metagpt` 目录加载 `gpt-4.yaml` 文件中的自定义配置
gpt4t = Config.default()  # 使用 `config2.yaml` 文件中的默认配置 (模型: "gpt-4-turbo")
gpt35 = Config.default()
gpt35.llm.model = "gpt-3.5-turbo"  # 将模型修改为 "gpt-3.5-turbo"

分配配置

创建配置后，你可以将它们分配给不同的角色和动作。

优先级：

• 动作配置 > 角色配置 > 全局配置 ( config2.yaml 文件中的配置)

示例：

假设你想要创建一个模拟美国大选直播的环境，包含三个角色：

• A: 民主党候选人
• B: 共和党候选人
• C: 选民

from metagpt.roles import Role
from metagpt.actions import Action

# 创建三个动作：a1、a2 和 a3。将 gpt4t 的配置分配给 a1。
a1 = Action(config=gpt4t, name="Say", instruction="用感情表达你的观点，不要重复")
a2 = Action(name="Say", instruction="用感情表达你的观点，不要重复")
a3 = Action(name="Vote", instruction="投票给候选人，并说明你为什么投票给他/她")

# 创建三个角色：A、B 和 C。分别代表“民主党候选人”、“共和党候选人”和“选民”。
# 虽然 A 在角色配置中配置了 gpt4，但由于动作配置设置，它将使用模型 gpt4t 的配置来执行 a1。
A = Role(name="A", profile="民主党候选人", goal="赢得选举", actions=[a1], watch=[a2], config=gpt4)
# 由于 B 在角色配置中配置了 gpt35，而 a2 没有动作配置，B 和 a2 都将使用角色配置，即模型 gpt35 的配置。
B = Role(name="B", profile="共和党候选人", goal="赢得选举", actions=[a2], watch=[a1], config=gpt35)
# 由于 C 没有设置配置，a3 也没有设置配置，C 和 a3 都将使用全局配置，即模型 gpt4 的配置。
C = Role(name="C", profile="选民", goal="投票给候选人", actions=[a3], watch=[a1, a2])

团队交互

完成配置后，你可以创建一个团队，并让它们进行交互。

示例：

import asyncio
from metagpt.environment import Environment
from metagpt.team import Team

# 创建一个名为“美国大选直播”的环境
env = Environment(desc="美国大选直播")
team = Team(investment=10.0, env=env, roles=[A, B, C])
# 运行团队，你应该能观察到它们之间的协作
asyncio.run(team.run(idea="主题：气候变化。每条消息不超过 80 个字。", send_to="A", n_round=3))
# await team.run(idea="主题：气候变化。每条消息不超过 80 个字。", send_to="A", n_round=3) # 如果在 Jupyter Notebook 中运行，使用此代码行

总结

本教程展示了如何使用 MetaGPT 为不同的角色和动作指定不同的 LLM，让你的 AI 团队更加灵活和真实。通过个性化配置，你可以让你的 AI 团队更加符合你的需求，并创造更加沉浸式的交互体验。

更多学习资源

• MetaGPT 文档：了解更多关于 MetaGPT 的信息。
• MetaGPT Github：查看 MetaGPT 的源代码和示例。
• MetaGPT 论文：深入了解 MetaGPT 的技术细节。

在之前的教程中，我们学习了如何创建和使用智能体、工具以及人机协作。但 MetaGPT 的真正强大之处在于它能够灵活地整合各种大型语言模型 (LLM)，包括开源模型。

本教程将带你学习如何将开源 LLM 整合到 MetaGPT 中，并利用它们来生成项目输出。

注意：

由于开源模型本身的限制，本教程中描述的内容无法保证稳定的代码生成。如果你按照本教程进行实验，意味着你已经了解这一点。同时，我们也在探索如何在开源模型下获得更稳定、更高质量的输出。如果你也对此感兴趣，可以加入我们的 Discord 或微信社区群组。相信随着开源模型的更新，这一目标很快就能实现。

整合流程

我们将按照以下步骤介绍本教程：

1. 模型部署： 使用 LLaMA-Factory、FastChat、ollama 等推理库部署相应的 LLM 模型。
2. LLM 配置： 配置 MetaGPT 以使用部署的 LLM 模型。
3. 可选：修复 LLM 输出： 修复开源 LLM 输出，以提高执行成功率。
4. 运行： 运行 MetaGPT，并观察结果。

模型部署

建议使用 OpenAI 兼容的接口进行模型部署。这样，请求和响应可以直接使用 OpenAI SDK 处理，简化了整合过程。以下推理库支持发布 OpenAI 兼容的接口（ollama 除外）：

• LLaMA-Factory: https://github.com/hiyouga/LLaMA-Factory
• FastChat: https://github.com/lm-sys/FastChat
• vllm: https://github.com/vllm-project/vllm
• ollama: https://github.com/jmorganca/ollama (不支持 OpenAI API 接口)

注意： 默认情况下，你需要有显卡资源进行部署，否则 CPU 推理会比较慢。

LLaMA-Factory

安装：

git clone https://github.com/hiyouga/LLaMA-Factory.git
conda create -n llama_factory python=3.10
conda activate llama_factory
cd LLaMA-Factory
pip install -r requirements.txt

部署：

• 启动源模型：

python3 src/api_demo.py \
    --model_name_or_path meta-llama/Llama-2-13b-chat-hf \
    --template llama2

• 加载和合并 LoRA 输出：

python3 src/api_demo.py \
    --model_name_or_path path_to_llama2_model \
    --template llama2 \
    --finetuning_type lora \
    --checkpoint_dir path_to_checkpoint

默认情况下，接口访问地址为 http://0.0.0.0:8000/。如果需要修改端口，请进入 src/api_demo.py 文件进行修改。如果需要使用多张显卡启动，请在启动命令前添加 CUDA_VISIBLE_DEVICES=0,1,2 并替换为你的显卡编号。不同的模型支持不同的模板值，可以在 src/llmtuner/data/template.py 文件中找到。

请求示例：

curl -X POST http://0.0.0.0:8000/v1/chat/completions -H "content-type:application/json" -d '{
  "messages":[{"role":"user","content":"who are you"}],
  "model": "gpt-3.5-turbo",
  "stream": false,
  "max_tokens": 256
}'

默认情况下，请求的模型参数值为 gpt-3.5-turbo，如有必要，请修改它。进入 src/llmtuner/api/app.py 文件的 list_models 方法，并修改为你的自定义值。

FastChat

安装：

pip3 install "fschat[model_worker,webui]"

部署：

• 启动控制器：

python3 -m fastchat.serve.controller

• 启动源模型工作器：

python3 -m fastchat.serve.model_worker --model-path lmsys/vicuna-13b-v1.5 --conv-template vicuna_v1.1 --model-names vicuna

• 启动 OpenAI 兼容接口：

python3 -m fastchat.serve.openai_api_server --host localhost --port 8000

如果你需要启动 LoRA 微调模型，需要先进行模型合并。

请求示例：

curl -X POST http://0.0.0.0:8000/v1/chat/completions -H "content-type:application/json" -d '{
  "messages":[{"role":"user","content":"who are you"}],
  "model": "gpt-3.5-turbo",
  "stream": false,
  "max_tokens": 256
}'

默认情况下，请求的模型参数值为 vicuna，对应于启动 model_worker 时指定的 model-names。

vllm

安装：

pip3 install vllm

部署：

python3 -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-13b-hf \
    --served-model-name llama2-13b

请求示例：

curl -X POST http://0.0.0.0:8000/v1/chat/completions -H "content-type:application/json" -d '{
  "messages":[{"role":"user","content":"who are you"}],
  "model": "llama2-13b",
  "stream": false,
  "max_tokens": 256
}'

默认情况下，请求的模型参数值为 llama2-13b，对应于启动时指定的 served-model-name。

ollama

安装：

curl https://ollama.ai/install.sh | sh

部署：

ollama run llama2  # 下载速度很快 (10+MB/s)

非本地访问：

ollama 服务默认情况下只能本地访问，即 http://localhost:11434/api/chat 或 http://127.0.0.1:11434/api/chat。如果你想要支持 http://ip:11434/api/chat，可以按照以下步骤操作：

service ollama stop

OLLAMA_HOST=0.0.0.0 OLLAMA_ORIGINS=* ollama serve  # 一个终端

ollama run llama2                                  # 另一个终端

请求示例：

# 默认情况下是非流式，`stream: true`
curl -X POST http://localhost:11434/api/chat -d '{
  "model": "llama2",
  "messages": [
    {
      "role": "user",
      "content": "why is the sky blue?"
    }
  ]
 }'

LLM 配置

完成模型部署后，需要修改 config/config2.yaml 文件来配置 MetaGPT 使用部署的 LLM 模型。

OpenAI 兼容接口

例如 LLaMA-Factory、FastChat、vllm 的 OpenAI 兼容接口：

llm:
  api_type: 'open_llm'
  base_url: 'http://106.75.10.xxx:8000/v1'
  model: 'llama2-13b'

base_url 只需要配置到 http://0.0.0.0:8000/v1，其余部分由 OpenAI SDK 自动填充。model 是请求接口参数 model 的实际值。

ollama API 接口

例如通过 ollama 部署的模型服务：

llm:
  api_type: 'ollama'
  base_url: 'http://127.0.0.1:11434/api'
  model: 'llama2'

base_url 只需要配置到 http://127.0.0.1:11434/api，其余部分由 Ollama LLM 自动填充。model 是请求参数 model 的实际值。

可选：修复 LLM 输出

背景：

本教程主要介绍如何在 MetaGPT 中整合开源模型（以及非 OpenAI 的闭源模型）。由于 LLM 的输出结果与提示词指令格式密切相关，开源模型（以及一些非 OpenAI 的闭源模型）往往非常复杂。它们很难完全按照 MetaGPT 现有角色的指令进行输出，导致输出内容缺失、遗漏和错误。主要表现如下：

• 目标键无法按照提示词约定的大小写进行输出。
• 输出的 JSON 纯文本包含缺失或多余的特殊字符，例如 {"a":b"}}, {"a":b"]}, {"a":b" 等等。

为了解决这些问题，MetaGPT 添加了修复开源 LLM 输出的功能。

配置：

llm: ...

repair_llm_output: true

开启此功能后，执行过程中会尝试修复上述情况。但目前该功能无法保证完全修复，仍存在一些未覆盖的情况（不同的开源模型有不同的情况），执行过程可能会中断并退出。如果你对此感兴趣，请提交 PR 并附上相应的模型描述、测试日志和单元测试用例。

开启此功能后，LLM 输出（MetaGPT 中软件公司中的 ProductManager 和 Architect 角色）将会被修复。日志中会出现 repair_ 关键字，你可以关注它。

运行

完成上述步骤后，你就可以正式开始使用了。

metagpt "write a snake game"

扩展

MetaGPT 本身是一个多智能体框架，并不局限于软件项目生成。你也可以结合整合的开源模型，构建相应的智能体，用于自己的应用场景。开始你的智能体之旅吧！

在之前的教程中，我们学习了如何创建和使用智能体以及工具。但有时候，我们希望在 AI 系统中引入人类的参与，例如在项目中进行质量保证、在关键决策中提供指导或在游戏中进行角色扮演。这就是 MetaGPT 人机协作功能发挥作用的地方。

本教程将带你学习如何将人类引入到 MetaGPT 的 AI 系统中，实现人机协作。

人机交互

MetaGPT 允许你在 LLM 驱动的智能体和人类之间进行交互。

示例：

我们以之前的多智能体教程为例。原本，SimpleReviewer 角色由 LLM 扮演。假设我们想要对审查过程有更多控制权，可以自己扮演 SimpleReviewer 角色。

只需要在初始化 SimpleReviewer 时设置 is_human=True 即可。代码如下：

team.hire(
    [
        SimpleCoder(),
        SimpleTester(),
        # SimpleReviewer(),  # 原代码
        SimpleReviewer(is_human=True),  # 修改后的代码
    ]
)

现在，你将以人类的身份扮演 SimpleReviewer，与两个 LLM 驱动的智能体 SimpleCoder 和 SimpleTester 进行交互。你可以对 SimpleTester 生成的单元测试进行评论，例如要求增加覆盖率或边缘情况测试。你的反馈将被发送回 SimpleTester，以便它编写新版本的测试用例。

交互方式

每次轮到人类进行响应时，运行过程将会暂停，等待你的输入。只需输入你想要的内容，你的消息就会被发送到智能体。

限制：

• 目前，交互是通过终端输入进行的，对于多行或结构化的文本输入不太方便。
• 用户必须遵守提示词的内容或格式要求，以便在人类输入后，逻辑能够正常运行。

总结

本教程展示了如何将人类引入到 MetaGPT 的 AI 系统中，实现人机协作。通过人机协作，你可以更好地控制 AI 系统，并发挥人类的优势，例如创造力、判断力等等。

更多学习资源

• MetaGPT 文档：了解更多关于 MetaGPT 的信息。
• MetaGPT Github：查看 MetaGPT 的源代码和示例。
• MetaGPT 论文：深入了解 MetaGPT 的技术细节。

在之前的教程中，我们学习了如何使用记忆来提升智能体的能力。但有时候，智能体需要与外部环境进行交互，例如获取信息、执行操作等等。这就是 MetaGPT 工具发挥作用的地方。

MetaGPT 工具可以帮助你的智能体扩展能力，就像给它安装了“外挂”一样。本教程将带你学习如何创建和使用 MetaGPT 工具。

创建工具

在 MetaGPT 中，创建工具非常简单，只需在 metagpt/tools/libs 目录中创建自己的函数或类即可。

步骤：

1. 创建函数或类： 编写函数或类，用于实现与外部环境的交互。
2. 添加 Google 风格的文档字符串： 为每个函数或类添加文档字符串，用于描述其用途、输入参数和预期输出。
3. 使用 @register_tool 装饰器： 使用 @register_tool 装饰器将函数或类注册到工具注册表中。

示例：

假设你想创建一个计算阶乘的工具，名为 calculate_factorial。你可以创建一个名为 calculate_factorial.py 的文件，并在其中添加以下代码：

# metagpt/tools/libs/calculate_factorial.py
import math
from metagpt.tools.tool_registry import register_tool

# 使用装饰器注册工具
@register_tool()
def calculate_factorial(n):
    """
    计算一个非负整数的阶乘。
    """
    if n < 0:
        raise ValueError("输入必须是非负整数")
    return math.factorial(n)

使用工具

创建工具后，你可以使用 DataInterpreter 角色来使用它。

示例：

假设你想要使用 calculate_factorial 工具来计算 5 的阶乘。你可以创建一个名为 main.py 的文件，并在其中添加以下代码：

# main.py
import asyncio
from metagpt.roles.di.data_interpreter import DataInterpreter
from metagpt.tools.libs import calculate_factorial

async def main(requirement: str):
   role = DataInterpreter(tools=["calculate_factorial"])  # 集成工具
   await role.run(requirement)

if __name__ == "__main__":
   requirement = "请计算 5 的阶乘。"
   asyncio.run(main(requirement))

这段代码首先导入必要的模块，然后定义一个 main 函数。在 main 函数中，我们创建了一个 DataInterpreter 角色，并使用 tools 参数指定了要使用的工具。最后，我们使用 role.run() 方法运行角色，并打印输出结果。

工具定制

MetaGPT 支持多种工具定制方式，例如：

• 从函数定制工具： 如上面的 calculate_factorial 示例。
• 从类定制工具： 你可以创建一个类，并使用 @register_tool 装饰器注册它。

示例：

假设你想创建一个名为 Calculator 的类，用于执行基本的算术运算和计算阶乘。你可以创建一个名为 calculator.py 的文件，并在其中添加以下代码：

# metagpt/tools/libs/calculator.py
import math
from metagpt.tools.tool_registry import register_tool

# 使用装饰器注册工具，并指定标签和包含的函数
@register_tool(tags=["math"], include_functions=["__init__", "add", "subtract", "multiply", "divide", "factorial"])
class Calculator:
   """
   一个简单的计算器工具，可以执行基本的算术运算和计算阶乘。
   """

   @staticmethod
   def add(a, b):
       """
       计算两个数字的和。
       """
       return a + b

   @staticmethod
   def subtract(a, b):
       """
       计算两个数字的差。
       """
       return a - b

   @staticmethod
   def multiply(a, b):
       """
       计算两个数字的积。
       """
       return a * b

   @staticmethod
   def divide(a, b):
       """
       计算两个数字的商。
       """
       if b == 0:
           return "错误：除数不能为零"
       else:
           return a / b

   @staticmethod
   def factorial(n):
       """
       计算一个非负整数的阶乘。
       """
       if n < 0:
           raise ValueError("输入必须是非负整数")
       return math.factorial(n)

总结

本教程展示了如何使用 MetaGPT 创建和使用工具。通过创建工具，你可以扩展智能体的能力，使其能够执行更复杂的任务。

更多学习资源

• MetaGPT 文档：了解更多关于 MetaGPT 的信息。
• MetaGPT Github：查看 MetaGPT 的源代码和示例。
• MetaGPT 论文：深入了解 MetaGPT 的技术细节。

在之前的教程中，我们已经了解了智能体和多智能体系统。但一个真正强大的 AI 智能体，还需要拥有记忆能力。记忆可以帮助智能体积累经验，并根据过去的经验进行决策和行动。

本教程将带你了解 MetaGPT 中的记忆功能，以及如何使用它来提升你的 AI 智能体的能力。

MetaGPT 中的记忆

在 MetaGPT 中，Memory 类是智能体记忆的抽象表示。当一个角色被初始化时，它会获得一个 Memory 对象，用于存储它观察到的所有消息。这些消息会被保存在一个列表中，方便以后检索。

检索记忆

当你需要使用记忆时，例如将记忆作为 LLM 的上下文，可以使用 self.get_memories() 方法。该方法的定义如下：

def get_memories(self, k=0) -> list[Message]:
    """A wrapper to return the most recent k memories of this role, return all when k=0"""
    return self.rc.memory.get(k=k)

该方法接受一个可选参数 k，用于指定要检索的最近记忆数量。如果 k 为 0，则返回所有记忆。

例如，在之前的多智能体教程中，我们使用 get_memories() 方法将所有记忆作为上下文提供给测试者。这样，如果审查者提供了反馈，测试者可以参考之前的版本修改测试用例。代码片段如下：

async def _act(self) -> Message:
    logger.info(f"{self._setting}: ready to {self.rc.todo}")
    todo = self.rc.todo

    # context = self.get_memories(k=1)[0].content  # 使用最近的记忆作为上下文
    context = self.get_memories()  # 使用所有记忆作为上下文

    code_text = await todo.run(context, k=5)  # 指定参数

    msg = Message(content=code_text, role=self.profile, cause_by=todo)

    return msg

添加记忆

要添加记忆，可以使用 self.rc.memory.add(msg) 方法，其中 msg 必须是 Message 类的实例。

建议在定义 _act 方法时，将动作输出的消息添加到角色的记忆中。角色通常需要记住它之前说过的话或做过的事，才能采取下一步行动。

下一步

本教程介绍了 MetaGPT 中的“短期记忆”概念。记忆的检索是基于简单的最近性原则。然而，还有许多其他类型的记忆，以及各种各样的记忆生成和检索技术。你可以参考 Memory 教程，了解如何使用记忆来真正提升你的智能体的性能。

在上一章中，我们学习了如何创建一个单个智能体。虽然单个智能体在许多情况下已经足够，但对于更复杂的任务，往往需要协作和团队合作。这就是多智能体系统发挥作用的地方。MetaGPT 的核心优势在于它能够轻松灵活地开发多个智能体组成的团队。在 MetaGPT 框架下，只需编写少量代码，就能实现智能体之间的交互。

通过本教程，你将学会：

• 理解智能体之间的交互方式
• 开发你的第一个 AI 团队
• 运行软件创业示例

开发你的第一个 AI 团队

让我们以软件创业为例，想象一下，你需要一个团队来开发一个 CLI 版本的 Flappy Bird 游戏：

metagpt "write a cli flappy bird game"

这个简单的命令就可以启动 MetaGPT，并让它自动组建一个 AI 团队来完成这个任务。

1. 定义角色和动作

与单个智能体类似，我们需要定义每个角色以及它们能够执行的动作。

• SimpleCoder: 接受用户指令，编写主要代码。
• SimpleTester: 接受 SimpleCoder 生成的代码，编写测试用例。
• SimpleReviewer: 接受 SimpleTester 生成的测试用例，审查其覆盖率和质量。

每个角色对应一个动作：

• SimpleWriteCode: 接受用户指令，生成 Python 代码。
• SimpleWriteTest: 接受代码，生成测试用例。
• SimpleWriteReview: 审查测试用例，并提供评论。

2. 定义角色

在 MetaGPT 中，定义一个角色通常只需要几行代码。

SimpleCoder:

class SimpleCoder(Role):
    name: str = "Alice"
    profile: str = "SimpleCoder"

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._watch([UserRequirement])  # 监听用户指令
        self.set_actions([SimpleWriteCode])

SimpleTester:

class SimpleTester(Role):
    name: str = "Bob"
    profile: str = "SimpleTester"

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.set_actions([SimpleWriteTest])
        self._watch([SimpleWriteCode])  # 监听 SimpleCoder 生成的代码
        # self._watch([SimpleWriteCode, SimpleWriteReview])  # 可以尝试监听更多信息

    async def _act(self) -> Message:
        logger.info(f"{self._setting}: to do {self.rc.todo}({self.rc.todo.name})")
        todo = self.rc.todo

        # context = self.get_memories(k=1)[0].content  # 使用最近的记忆作为上下文
        context = self.get_memories()  # 使用所有记忆作为上下文

        code_text = await todo.run(context, k=5)  # 指定参数
        msg = Message(content=code_text, role=self.profile, cause_by=type(todo))

        return msg

SimpleReviewer:

class SimpleReviewer(Role):
    name: str = "Charlie"
    profile: str = "SimpleReviewer"

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.set_actions([SimpleWriteReview])
        self._watch([SimpleWriteTest])  # 监听 SimpleTester 生成的测试用例

3. 创建团队

现在，我们已经定义了三个角色，可以将它们组合成一个团队：

import asyncio
import typer
from metagpt.logs import logger
from metagpt.team import Team
app = typer.Typer()

@app.command()
def main(
    idea: str = typer.Argument(..., help="write a function that calculates the product of a list"),
    investment: float = typer.Option(default=3.0, help="Dollar amount to invest in the AI company."),
    n_round: int = typer.Option(default=5, help="Number of rounds for the simulation."),
):
    logger.info(idea)

    team = Team()
    team.hire(
        [
            SimpleCoder(),
            SimpleTester(),
            SimpleReviewer(),
        ]
    )

    team.invest(investment=investment)
    team.run_project(idea)
    asyncio.run(team.run(n_round=n_round))

if __name__ == '__main__':
    app()

这段代码首先定义了一个 main 函数，并创建一个 Team 对象。然后，我们使用 team.hire() 方法雇佣了三个角色。最后，我们使用 team.run() 方法运行团队，并打印输出结果。

运行团队

现在，你可以运行这段代码，并观察团队之间的协作：

python3 examples/build_customized_multi_agents.py --idea "write a function that calculates the product of a list"

总结

本教程展示了如何使用 MetaGPT 创建一个简单的 AI 团队，并演示了如何定义角色和动作，以及如何运行团队。你可以在此基础上进一步扩展你的团队，使其能够执行更复杂的任务。

更多学习资源

• MetaGPT 文档：了解更多关于 MetaGPT 的信息。
• MetaGPT Github：查看 MetaGPT 的源代码和示例。
• MetaGPT 论文：深入了解 MetaGPT 的技术细节。