大语言模型-检索增强生成和知识图谱的人工智能体构建指南-全-

大语言模型、检索增强生成和知识图谱的人工智能体构建指南(全)

原文:zh.annas-archive.org/md5/7f895f3dd97095da095ae95fcffc355d

译者:飞龙

协议:CC BY-NC-SA 4.0

前言

使用 LLMs、RAG 和知识图谱构建 AI 代理介绍了大型语言模型(LLMs)和 AI 代理不断发展的领域,提供了理论基础和实践指导。它首先解释了如何使用深度学习表示和处理文本数据,然后过渡到现代架构如 Transformer 模型。从那里,本书探讨了如何扩展 LLMs 的规模和微调,以及如何通过工具、外部记忆系统和基于代理的框架来扩展其功能。详细解释了检索增强生成(RAG)、GraphRAG 和多代理系统等技术,重点关注实际应用和部署。到本书结束时,你将清楚地了解如何构建智能的、使用工具的 AI 代理以及这些系统在塑造 AI 未来中所扮演的角色。

这本书面向谁

这本书旨在为想要理解和构建使用 LLMs 和 AI 代理的应用程序的软件工程师、数据科学家和研究人员而编写。建议具备基本的 Python 编程知识和机器学习基础概念,以便充分利用本书内容。虽然不需要在 NLP 方面有深入的专业知识,但熟悉神经网络、REST API 和一般的软件开发实践将有助于你理解示例并实现实际系统。无论你是想构建智能代理、探索 LLMs 的内部工作原理,还是大规模部署 AI 应用程序,本书都提供了开始的理论背景和实践指导。

这本书涵盖的内容

第一章,使用深度学习分析文本数据,介绍了如何将自然语言处理成适合机器学习模型格式的处理和表示方法。它涵盖了从基本的 one-hot 编码和词袋模型到更高级的表示方法,如 TF-IDF 和 word2vec。本章接着探讨了用于序列数据的深度学习关键架构,例如 RNNs、LSTMs、GRUs 和 CNNs,并展示了如何将它们应用于文本分类任务。到本章结束时,你将了解这些基础如何使现代语言模型如 ChatGPT 成为可能。

第二章,Transformer:现代 AI 革命的模型背后,介绍了注意力机制并解释了它们如何演变成 Transformer 架构。本章突出了早期模型如 RNNs 和 LSTMs 的局限性,并展示了 Transformer 如何克服这些局限性,成为现代 NLP 的基础。关键主题包括自注意力、掩码语言建模、训练技术以及内部模型可视化。本章最后通过展示实际应用和为理解今天的 LLMs 奠定基础来结束。

第三章, 探索 LLM 作为强大的 AI 引擎,考察了大规模训练 transformer 模型如何导致今天 LLMs 的出现。本章探讨了它们的演变、能力和局限性,包括指令微调、微调和对齐等技术。它还介绍了更紧凑和高效的 LLM 变体、处理多种数据类型的多模态模型,以及幻觉、伦理担忧和提示工程等理解挑战。

第四章, 使用 LLM 构建网络爬虫代理,介绍了 AI 代理作为 LLMs 的扩展概念,旨在克服它们执行动作的能力。本章探讨了代理的关键特征,以及单代理和多代理系统之间的区别。它还介绍了用于构建代理的主要库,并指导你创建一个能够从互联网检索信息的网络爬虫代理。

第五章, 使用 RAG 扩展您的代理以防止幻觉,探讨了 RAG 如何克服 LLMs 的关键局限性,如知识过时和幻觉。本章解释了 RAG 如何通过嵌入和向量数据库使 LLM 能够访问外部信息源,从而提高准确性和适应性。它还比较了 RAG 与微调,并通过构建电影推荐代理展示了其实际应用。

第六章, 高级 RAG 技术用于信息检索和增强,通过在管道的每个阶段引入增强来扩展基本的 RAG 架构——数据摄取、索引、检索和生成。本章探讨了模块化 RAG、用于扩展具有大型数据集和用户群的系统的技术,以及稳健性和隐私等关键问题。它还强调了围绕基于 RAG 的系统未来发展的当前挑战和开放性问题。

第七章, 将知识图谱与 AI 代理连接起来创建和连接知识图谱,探讨了如何将文本知识结构化到知识图谱(KGs)中,以增强 AI 代理中的信息检索和推理。本章介绍了 GraphRAG 的概念,其中 KGs 用于通过结构化上下文数据来增强 LLMs。它涵盖了如何使用 LLMs 通过提取实体和关系来构建 KGs,如何使用图进行查询和推理,并讨论了结合不同方法的益处、局限性和未来方向。

第八章, 强化学习和人工智能代理,探讨了代理如何通过与动态环境互动、根据经验调整其行为来学习。它介绍了强化学习的基本原理,解释了代理如何做出决策并在时间上改进,并展示了如何使用神经网络来引导行为。本章最后讨论了如何将 LLMs 与强化学习相结合来构建更强大的 AI 系统。

第九章, 创建单代理和多代理系统,探讨了如何通过工具和其他模型扩展 LLMs 以形成自主代理。它介绍了单代理和多代理系统的概念,展示了 LLMs 如何与 API 或外部模型交互,并提出了如 HuggingGPT 等关键示例。本章还涵盖了代理协调策略、复杂领域的现实应用以及如 SaaS、MaaS、DaaS 和 RaaS 等新兴商业模式。

第十章, 构建人工智能代理应用,探讨了在现实应用中扩展和部署人工智能代理所面临的挑战。它介绍了 Streamlit 作为一个快速原型设计框架,用于创建基于代理系统的前端和后端组件。本章还涵盖了关键操作方面,如异步编程、使用 Docker 的容器化以及构建可扩展、生产就绪的人工智能解决方案的最佳实践。

第十一章, 未来展望,探讨了人工智能代理在医疗保健等行业以及更广泛的领域的变革潜力。基于前几章讨论的进展,它反思了 LLMs 和代理系统面临的剩余技术和伦理挑战。本章最后通过探讨智能人工智能代理的开发和部署中的开放问题和未来方向来结束。

为了充分利用本书

您应该具备基本的 Python 知识,并熟悉诸如函数、类和模块等基本编程概念。对机器学习和神经网络(如模型是什么以及训练是如何进行的)的一般了解将有助于理解更深层次的技术内容。虽然不需要有深度学习框架或 LLMs 的先前经验,但它将增强您应用所讨论技术的能力。本书旨在循序渐进,因此概念是逐步引入的,但技术思维是必不可少的。

本书涵盖的软件/硬件 操作系统要求
Python 3.10+ Windows、macOS 或 Linux
PyTorch/Transformers Windows、macOS 或 Linux
Streamlit Windows、macOS 或 Linux
Docker Windows、macOS 或 Linux

对于没有访问本地 GPU 的读者,使用 Google Colab 是一个方便的选择。建议使用 Google Colab Pro 账户,因为它提供了访问更强大的 GPU,如 NVIDIA T4 或 A100,这可以在运行嵌入模型、微调或与代理一起工作时大大提高性能。

如果你使用的是本书的数字版,我们建议你亲自输入代码或从书的 GitHub 仓库(下一节中有一个链接)获取代码。这样做将帮助你避免与代码的复制和粘贴相关的任何潜在错误。

下载示例代码文件

你可以从 GitHub 下载本书的示例代码文件,网址为github.com/PacktPublishing/Modern-AI-Agents/tree/main。如果代码有更新,它将在 GitHub 仓库中更新。

我们还有其他来自我们丰富图书和视频目录的代码包可供在github.com/PacktPublishing/下载。查看它们吧!

使用的约定

本书使用了多种文本约定。

文本中的代码: 表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 X/Twitter 用户名。以下是一个示例:“process_frame函数用于从游戏中预处理帧,使其更适合训练 RL 代理。”

代码块是这样设置的:

self.critic_linear = nn.Linear(512, 1)
self.actor_linear = nn.Linear(512, num_actions)

当我们希望将你的注意力引到代码块的一个特定部分时,相关的行或项目将以粗体显示:

[default]
exten => s,1,Dial(Zap/1|30)
exten => s,2,Voicemail(u100)
exten => s,102,Voicemail(b100)
exten => i,1,Voicemail(s0)

任何命令行输入或输出都应如下编写:

streamlit run https://raw.githubusercontent.com/streamlit/my_apps/ master/my_app.py

粗体: 表示新术语、重要单词或你在屏幕上看到的单词。例如,菜单或对话框中的单词以粗体显示。以下是一个示例:“一旦我们准备好了标记,我们就可以输入问题并点击提交。”

小贴士或重要注意事项

它看起来像这样。

联系我们

欢迎读者反馈。

一般反馈: 如果你对此书任何方面有疑问,请通过 customercare@packtpub.com 给我们发邮件,并在邮件主题中提及书名。

勘误: 尽管我们已经尽一切努力确保内容的准确性,但错误仍然可能发生。如果你在这本书中发现了错误,我们将不胜感激,如果你能向我们报告这一点。请访问www.packtpub.com/support/errata并填写表格。

盗版: 如果你在互联网上以任何形式遇到我们作品的非法副本,如果你能提供位置地址或网站名称,我们将不胜感激。请通过版权@packt.com 与我们联系,并提供材料的链接。

如果您有兴趣成为作者:如果您在某个领域有专业知识,并且您有兴趣撰写或为书籍做出贡献,请访问authors.packtpub.com。

分享您的想法

一旦您阅读了《使用 LLMs、RAG 和知识图谱构建 AI 代理》,我们非常乐意听到您的想法!请点击此处直接转到该书的亚马逊评论页面并分享您的反馈。

您的评论对我们和科技社区非常重要,并将帮助我们确保我们提供高质量的内容。

下载此书的免费 PDF 副本

感谢您购买此书!

您喜欢在路上阅读,但无法携带您的印刷书籍到处走吗?

您的电子书购买是否与您选择的设备不兼容?

别担心,现在购买每一本 Packt 书籍,您都可以免费获得该书的 DRM 免费 PDF 版本。

在任何地方、任何设备上阅读。直接从您喜欢的技术书籍中搜索、复制和粘贴代码到您的应用程序中。

优惠不止于此,您还可以获得独家折扣、时事通讯和每日免费内容的每日电子邮件访问权限。

按照以下简单步骤获取福利:

  1. 扫描二维码或访问以下链接

packt.link/free-ebook/978-1-83508-706-0

  1. 提交您的购买证明

  2. 就这些!我们将直接将您的免费 PDF 和其他福利发送到您的电子邮件中

第一部分:AI 代理引擎:从文本到大型语言模型

本部分为理解现代 AI 代理如何处理和生成语言奠定了基础。它首先探讨了原始文本如何以适合深度学习模型的数值形式表示,介绍了诸如词嵌入和基本神经网络架构等技术。然后,重点转向 Transformer 模型,并解释了注意力机制如何革新自然语言处理。最后,它探讨了通过扩展 Transformer 来构建大型语言模型(LLMs),讨论了训练策略、指令调整、微调和向通用推理模型演化的过程。这些章节共同为构建智能 AI 代理提供了技术和概念基础。

本部分包含以下章节:

  • 第一章**,使用深度学习分析文本数据

  • 第二章**,Transformer:现代 AI 革命的模型背后

  • 第三章**,探索 LLMs 作为强大的 AI 引擎

第一章:使用深度学习分析文本数据

语言是人类最惊人的能力之一;它在个体的生命周期中不断发展,能够传达具有复杂意义的消息。自然形式下的语言对机器来说是不可理解的,开发一个能够捕捉不同细微差异的算法极具挑战性。因此,在本章中,我们将讨论如何将文本表示成机器可以消化和理解的形式。

在自然形式下,文本不能直接输入到深度学习模型中。在本章中,我们将讨论如何将文本表示成可以被机器学习模型使用的形式。从自然文本开始,我们将文本转换成越来越复杂的数值向量(one-hot 编码、词袋模型(BoW)、词频-逆文档频率(TF-IDF)),直到我们创建出代表一个词(或文档)意义的实数向量,并允许我们进行操作(word2vec)。在本章中,我们介绍了深度学习模型,如循环神经网络(RNNs)、长短期记忆(LSTM)、门控循环单元(GRUs)和卷积神经网络(CNNs),用于分析序列,并讨论它们的优点以及与之相关的问题。最后,我们将这些模型组合在一起进行文本分类,展示学习方法的强大之处。

到本章结束时,我们将能够使用文本语料库并利用深度学习进行分析。这些基础将帮助我们理解大型语言模型(LLM)(如 ChatGPT)的内部工作原理。

在本章中,我们将涵盖以下主题:

  • 为 AI 表示文本

  • 嵌入、应用和表示

  • 用于文本的 RNNs、LSTMs、GRUs 和 CNNs

  • 使用嵌入和深度学习进行情感分析

技术要求

在本章中,我们将使用 Python 的标准库。必要的库可以在本章节 GitHub 仓库中的每个 Jupyter 笔记本中找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr1。代码可以在 CPU 上执行,但建议使用 GPU。

为 AI 表示文本

与其他类型的数据(如图像或表格)相比,将文本以可消化的形式表示给计算机是一个更大的挑战,尤其是由于一个词的意义(所指)与其所代表的符号(能指)之间没有唯一的关系。实际上,一个词的意义会随着上下文和作者在句子中使用它的意图而变化。此外,原生文本必须转换成数值表示,以便算法可以处理,这并非易事。尽管如此,最初开发了几种方法来找到文本的向量表示。这些向量表示的优点在于它们可以被用作计算机的输入。

首先,应该将文本集合(语料库)划分为基本单元(单词)。这个过程需要做出某些决定和操作,这些操作统称为文本归一化。因此,一个句子通过利用空格的自然分隔(文本分割)被划分为单词;每个标点符号也被视为一个单独的单词。实际上,标点符号被认为是句子的边界,并传达重要的信息(主题变化、疑问、感叹)。

第二步是定义一个词是什么,以及语料库中的一些术语是否应该直接归入同一个词汇实例。例如,“He”和“he”代表同一个实例;前者仅大写。由于算法不包括这样的细微差别,因此必须将文本规范化为小写。在某些情况下,我们希望进行更复杂的规范化,例如词形还原(将具有相同词根的单词连接起来:“came”和“comes”是动词的两种形式)或词干提取(去除单词的所有后缀)。

分词是将文本转换为基本单元的任务。这是因为,除了单词之外,文本还可能包括百分比、数字、网站和其他组件。我们将在稍后回到这一点,但在此同时,我们将看看一些更简单的分词形式。

独热编码

在传统的自然语言处理(NLP)中,文本表示使用离散符号进行。最简单的例子是独热编码。从一个语料库中的文本序列(由n个不同的单词组成),我们得到一个n维向量。实际上,第一步是计算整个文本语料库中存在的不同单词集合,称为词汇表。对于每个单词,我们得到一个与词汇表大小相同的向量。然后对于每个单词,我们将有一个主要由零和一组成的长向量来表示该单词(独热向量)。这个系统主要用于当我们想要一个特征矩阵并训练一个模型时。这个过程也称为向量化;以下是一个稀疏向量的例子:

re<mi}staurant=000001000

pizzeria=001000000

与这种表示相关的问题有很多。首先,它只捕捉到文档中单词的存在(或不存在)。因此,我们失去了单词之间的所有语义关系。其次,平均语言大约有 200,000 个单词,所以对于每个单词,我们会有一个长度为 200,000 的向量。这导致向量非常稀疏且维度很高。对于大型语料库,我们需要大量的内存来存储这些向量,以及高计算能力来处理它们。此外,没有相似性的概念。前一个例子中的两个单词是两个卖食物的地方,我们希望代表这些单词的向量能够编码这种相似性。如果向量有相似性的概念,我们就可以进行聚类,同义词将位于同一个簇中。

为了获得这样的矩阵,我们必须执行以下操作:

  • 在分词之前标准化文本。在这种情况下,我们只是将所有内容转换为小写。

  • 我们构建一个由唯一单词组成的词汇表,并将其保存下来,以便在向量中可以获取相应的单词。

  • 我们创建一个数组,然后在其词汇表中单词的索引位置填充 1,其他位置填充 0。

让我们看看代码是如何实现这一点的:

import numpy as np
def one_hot_encoding(sentence):
    words = sentence.lower().split()
    vocabulary = sorted(set(words))
    word_to_index = {word: i for i,
        word in enumerate(vocabulary)}
    one_hot_matrix = np.zeros((
        len(words), len(vocabulary)), dtype=int)
    for i, word in enumerate(words):
        one_hot_matrix[i, word_to_index[word]] = 1
    return one_hot_matrix, vocabulary

让我们来看一个具体的例子:

sentence = "Should we go to a pizzeria or do you prefer a restaurant?"
one_hot_matrix, vocabulary = one_hot_encoding(sentence)
print("Vocabulary:", vocabulary)
print("One-Hot Encoding Matrix:\n", one_hot_matrix)

我们得到以下输出:

重要提示

观察选择另一个句子将如何导致不同的矩阵,以及通过增加句子的长度,矩阵如何成比例地增长到不同单词的数量。此外,请注意,对于重复的单词,我们得到相同的向量。检查前面的输出。

即使这是一个简单的方法,我们也得到了文本向量化形式的第一种表示。

词袋模型

在上一节中,我们讨论了一热编码以及与这种文本表示形式相关的一些问题。在之前的例子中,我们处理了一个句子,但语料库由成千上万甚至数百万个文档组成;每个文档都包含不同频率的几个单词。我们希望有一个系统可以保留这些频率信息,因为它对于文本的分类很重要。事实上,内容相似的文档是相似的,它们的含义也将是相似的。

BoW 是一种从文本中提取特征并保留此频率属性的算法。BoW 是一个非常简单的算法,它忽略了文本中单词的位置,只考虑这种频率属性。名称“bag”正是由于算法不保留关于句子顺序和结构的信息。对于 BoW,我们只需要一个词汇表和一种能够计数单词的方法。在这种情况下,我们的想法是创建文档向量:一个向量代表一个文档,以及词汇表中包含的单词的频率。图 1**.1 使用《哈姆雷特》的一些行来可视化这个概念:

Figure 1.1 – BoW 算法的表示

图 1.1 – BoW 算法的表示

即使这种表示法也存在问题。同样,随着词汇量的增加,向量的尺寸(每个向量的尺寸等于词汇表的长度)也会增加。此外,这些向量往往分布得很散,尤其是当文档彼此非常不同时。高维或稀疏向量不仅对内存和计算成本有影响,而且对算法也有影响(向量越长,算法中需要的权重就越多,从而导致过拟合的风险)。这被称为维度诅咒;特征的数量越多,示例之间的距离就越没有意义。对于大型语料库,已经提出了一些解决方案,例如忽略标点符号、纠正拼写错误、词干算法,或者忽略那些不增加信息的高频词(如冠词、介词等)。

为了为文档列表获取一个词袋矩阵,我们需要做以下几步:

  • 将每个文档分词,以获得一个单词列表。

  • 创建我们独特的词汇表,并将每个词映射到词汇表中的相应索引。

  • 创建一个矩阵,其中每一行代表一个文档,而每一列则代表词汇表中的一个词(文档是例子,而单词是相关特征)。

让我们再次查看代码:

import numpy as np
def bag_of_words(sentences):
    """
    Creates a bag-of-words representation of a list of documents.
    """
    tokenized_sentences = [
        sentence.lower().split() for sentence in sentences
    ]
    flat_words = [
        word for sublist in tokenized_sentences for word in sublist
    ]
    vocabulary = sorted(set(flat_words))
    word_to_index = {word: i for i, word in enumerate(vocabulary)}
    bow_matrix = np.zeros((
        len(sentences), len(vocabulary)), dtype=int)
    for i, sentence in enumerate(tokenized_sentences):
        for word in sentence:
            if word in word_to_index:
                bow_matrix[i, word_to_index[word]] += 1
    return vocabulary, bow_matrix

这里有一个例子:

corpus = ["This movie is awesome awesome",
          "I do not say is good, but neither awesome",
          "Awesome? Only a fool can say that"]
vocabulary, bow_matrix = bag_of_words(corpus)
print("Vocabulary:", vocabulary)
print("Bag of Words Matrix:\n", bow_matrix)

这将输出以下内容:

重要注意事项

注意在例子中,单词“awesome”与具有积极、中性或负面意义的评论相关联。没有上下文,单词awesome的频率本身并不能告诉我们评论的情感。

在这里,我们已经学会了如何将文本转换为向量形式,同时保持每个单词的频率概念。

TF-IDF

在上一节中,我们获得了一个文档-词矩阵。然而,原始频率分布非常不均匀,并不总是能让我们区分两个文档。文档-词矩阵起源于信息检索,用于查找文档,尽管像“好”或“坏”这样的词并不具有很强的区分性,因为它们通常在具有通用意义的文本中使用。相比之下,低频词更有信息量,所以我们更感兴趣的是相对频率而不是绝对频率:

图 1.2 – TF-IDF 各组成部分的直观理解

图 1.2 – TF-IDF 各组成部分的直观理解

我们可以使用以 10 为底的对数代替原始频率,因为一个在文档中出现 100 次的单词并不比它在文档中的意义相关性强 100 倍。当然,由于向量可以非常稀疏,如果频率为 0,我们则分配 0。其次,我们希望更多地关注仅存在于某些文档中的单词。这些单词将更相关于文档的意义,我们希望保留这些信息。为此,我们通过 IDF 进行规范化。IDF 定义为语料库中总文档数与一个术语出现在多少文档中的比率。总结来说,为了获得 TF-IDF,我们将 TF 乘以 IDF 的对数。

这在以下代码块中得到了演示:

import numpy as np
def compute_tf(sentences):
    """Compute the term frequency matrix for a list of sentences."""
    vocabulary = sorted(set(
        word for sentence in sentences
        for word in sentence.lower().split()))
    word_index = {word: i for i, word in enumerate(vocabulary)}
    tf = np.zeros((
        len(sentences), len(vocabulary)), dtype=np.float32)
    for i, sentence in enumerate(sentences):
        words = sentence.lower().split()
        word_count = len(words)
        for word in words:
            if word in word_index:
                tf[i, word_index[word]] += 1 / word_count
    return tf, vocabulary
def compute_idf(sentences, vocabulary):
    """Compute the inverse document frequency for a list of sentences."""
    num_documents = len(sentences)
    idf = np.zeros(len(vocabulary), dtype=np.float32)
    word_index = {word: i for i, word in enumerate(vocabulary)}
    for word in vocabulary:
        df = sum(
            1 for sentence in sentences
            if word in sentence.lower().split()
        )
        idf[word_index[word]] = np.log(
            num_documents / (1 + df)) + 1  # Smoothing
    return idf
def tf_idf(sentences):
    """Generate a TF-IDF matrix for a list of sentences."""
    tf, vocabulary = compute_tf(sentences)
    idf = compute_idf(sentences, vocabulary)
    tf_idf_matrix = tf * idf
    return vocabulary, tf_idf_matrix
vocabulary, tf_idf_matrix = tf_idf(corpus)
print("Vocabulary:", vocabulary)
print("TF-IDF Matrix:\n", tf_idf_matrix)

这生成了以下输出:

重要提示

在本例中,我们使用了与上一节相同的语料库。注意在规范化之后单词频率是如何变化的。

在本节中,我们学习了如何规范化文本以减少最频繁单词的影响,并赋予特定于文档子集的单词相关性。接下来,我们将讨论嵌入。

嵌入、应用和表示

在上一节中,我们讨论了如何使用向量来表示文本。这些向量对计算机来说是可消化的,但它们仍然存在一些问题(稀疏性、高维性等)。根据分布假设,具有相似意义的单词经常出现在一起(或者经常出现在相同上下文中的单词具有相同的意义)。同样,一个单词可以根据其上下文有不同的意义:“我去银行存钱”或“我们去河边野餐。”在下面的图中,我们有嵌入过程的高级表示。因此,我们希望有一个过程,使我们能够从文本开始,获得一个向量数组,其中每个向量对应于一个单词的表示。在这种情况下,我们希望有一个模型,然后允许我们将每个单词映射到向量表示。在下一节中,我们将详细描述这个过程,并讨论其背后的理论。

图 1.3 – 嵌入过程的概述

图 1.3 – 嵌入过程的高级表示

因此,我们希望生成尺寸小、由实数(密集)数字组成,并且保留这种上下文信息的向量。因此,目的是拥有有限大小的向量,可以表示一个单词的意义。我们之前获得的散点向量不能有效地用于数学运算或下游任务。此外,词汇表中的单词越多,我们得到的向量尺寸就越大。因此,我们希望得到的是尺寸小、由实数组成的密集向量,并且其尺寸不会随着词汇表中单词数量的增加而增加。

此外,这些向量具有词语意义的分布式表示(而在稀疏向量中,它是局部的或1所在的位置)。正如我们稍后将看到的,这些密集向量可以用于不同的操作,因为它们更好地代表了词语之间相似性的概念。这些密集向量被称为词嵌入。

这个概念是在 2013 年由 Mikolov 提出的,名为word2vec的框架,将在下一节中详细介绍。

Word2vec

word2vec 背后的直觉很简单:从其上下文中预测一个词 w。为此,我们需要一个神经网络和大量语料库。革命性的想法是,通过训练这个神经网络来预测哪些词 c 需要靠近目标词 w,神经网络的权重将是嵌入向量。这个模型是自监督的;在这种情况下,标签是隐含的,我们不提供它们。

Word2vec 通过两种方式简化了这个想法,使其系统在速度和效率上都非常快:通过将任务转化为二元分类(词 c 是否在词 w 的上下文中需要?是或否?)并使用逻辑回归分类器:

图 1.4 – 在 word2vec 中,我们滑动一个上下文窗口(这里表示为三个词的上下文窗口),然后我们随机采样一些负向词

图 1.4 – 在 word2vec 中,我们滑动一个上下文窗口(这里表示为三个词的上下文窗口),然后我们随机采样一些负向词

给定一个文本 t,我们在窗口 c(我们的上下文)中滚动一个以词 w 为中心的窗口;它周围的词是正类示例。之后,我们选择其他随机词作为负例。最后,我们训练一个模型来分类正例和负例;模型的权重是我们的嵌入。

给定一个词 w 和一个词 c,我们希望词 c 在 w 的上下文中的概率与它的嵌入相似度相似。换句话说,如果代表 w 和 c 的向量相似,c 必须经常出现在 w 的上下文中(word2vec 基于上下文相似性的概念)。我们通过两个嵌入向量之间的点积来定义这种嵌入相似度(我们使用 sigmoid 函数将这个点积转换为概率,从而允许比较)。因此,c 在 w 的上下文中的概率等于它们的嵌入相似的概率:

P+|w,c=σc∙w=11+exp−c∙w

这是对上下文中的所有单词 L 进行的操作。为了简化,我们假设上下文窗口中的所有单词都是独立的,因此我们可以将各种单词 c 的概率相乘。同样,我们希望确保不在单词 w 的上下文中的单词的点积是最小的。因此,一方面,我们最大化上下文中的单词的概率,另一方面,我们最小化不在上下文中的单词的概率。实际上,不在 w 的上下文中的单词在训练过程中是随机提取的,过程是相同的:

P+|w,c=∏i=1L11+exp−ci∙w

P−|w,c=∏i=1L11+expci∙w

为了简化,我们取概率的对数:

logP+|w,c=∑i=1Llog(11+exp−ci∙w)

logP−|w,c=∑i=1Llog(11+expci∙w)

权重矩阵 w 是我们的嵌入;这是我们接下来将要使用的。实际上,模型学习两个向量矩阵(一个用于 w,一个用于 c),但这两个矩阵非常相似,所以我们只取一个。然后我们使用交叉熵来训练模型并学习每个向量的权重:

<mml:math display="block">mml:msubmml:mrowmml:miL</mml:mi></mml:mrow>mml:mrowmml:miC</mml:mi>mml:miE</mml:mi></mml:mrow></mml:msub>mml:mo=</mml:mo>mml:mo-</mml:mo>mml:mil</mml:mi>mml:mio</mml:mi>mml:mig</mml:mi>mml:miP</mml:mi><mml:mfenced separators="|">mml:mrowmml:mo+</mml:mo></mml:mrow>mml:mrowmml:miw</mml:mi>mml:mo,</mml:mo>mml:mic</mml:mi>mml:mip</mml:mi>mml:mio</mml:mi>mml:mis</mml:mi></mml:mrow></mml:mfenced>mml:mo+</mml:mo>mml:mrowmml:munderover<mml:mo stretchy="false">∑</mml:mo>mml:mrowmml:mii</mml:mi>mml:mo=</mml:mo>mml:mn1</mml:mn></mml:mrow>mml:mrowmml:miL</mml:mi></mml:mrow></mml:munderover>mml:mrowmml:mil</mml:mi>mml:mio</mml:mi>mml:mig</mml:mi>mml:miP</mml:mi><mml:mfenced separators="|">mml:mrowmml:mo-</mml:mo></mml:mrow>mml:mrowmml:miw</mml:mi>mml:mo,</mml:mo>mml:mic</mml:mi>mml:min</mml:mi>mml:mie</mml:mi>mml:mig</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:mrow></mml:math>

这在以下图表中得到了直观的表示:

图 1.5 – 单词和上下文嵌入

图 1.5 – 单词和上下文嵌入

以下选择会影响嵌入的质量:

  • 数据质量至关重要。例如,利用维基百科可以更好地嵌入语义任务,而使用新闻可以提高句法任务的性能(推荐使用两者的混合)。使用 Twitter 或其他社交网络可能会引入偏差。

  • 同时,更多的文本可以提高嵌入性能。大量的文本可以部分弥补质量较差的问题,但代价是更长的训练时间(例如,Common Crawl 是从互联网下载的巨大数据集,尽管相当脏乱)。

  • 维度数量是另一个重要因素。嵌入的大小越大,性能越好。300 被认为是一个理想的点,因为超过这个大小,性能的提升并不显著。

  • 上下文窗口的大小也有影响。通常,上下文窗口为 4,但 2 个上下文窗口的向量能更好地识别词性。相比之下,如果我们对更广泛的相似度感兴趣,长上下文窗口更有用。

在 Python 中,我们可以使用以下代码轻松地从标记列表中获取嵌入:

from gensim.models import Word2Vec
model = Word2Vec(sentences=list_of_tokens,
                 sg=1,
                 vector_size=100,
                 window=5,
                 workers=4)

重要注意事项

完整的代码位于 GitHub 仓库中。我们使用了 100 维的嵌入和一个 5 词的窗口。

一旦我们有了嵌入,我们就可以可视化它。例如,如果我们尝试聚类一些单词的向量,具有相似意义的单词应该更靠近:

图 1.6 – 从嵌入中获得的某些向量的聚类

图 1.6 – 从嵌入中获得的某些向量的聚类

另一种可视化向量的方法是使用降维技术。向量是多维的(100-1,024),因此将它们降低到两或三个维度以便更容易可视化会更方便。一些最常用的技术是主成分分析(PCA)和t 分布随机邻域嵌入(t-SNE)。另一方面,统一流形近似和投影(UMAP)是一种近年来成为可视化多维数据的首选技术:

图 1.7 – word2vec 嵌入的 2D 投影,突出显示了一些示例

图 1.7 – word2vec 嵌入的 2D 投影,突出显示了一些示例

UMAP 之所以出现,是因为它产生的可视化更好地保留了示例之间的语义意义和关系,同时也更好地表示了局部和全局结构。这使得聚类更好,UMAP 也可以在向量分类任务之前的预处理步骤中使用。

文本相似度概念

一旦我们获得了向量表示,我们需要一种方法来计算它们之间的相似度。这在许多应用中至关重要——例如,为了找到嵌入空间中最接近给定单词的单词,我们计算其向量与其他单词向量的相似度。同样,给定一个查询句子,我们可以通过比较其向量与文档嵌入并选择那些相似度最高的来检索最相关的文档。

大多数相似度度量都是基于点积。这是因为当两个向量在同一维度上有值时,点积很高。相比之下,交替为零的向量将具有零点积,因此是正交或不相似的。这就是为什么点积被用作单词共现矩阵或从文档 TF 矩阵导出的向量之间的相似度度量:

dotproduct:a∙b=∑i=1Nai×bi=a1×b1+a2×b2+⋯an×bn

magnitude=a=∑i=1Nai22

点积有几个问题,尽管如此:

  • 它倾向于偏好长维度的向量

  • 它倾向于高值向量(通常是非常频繁的词,因此是无用的词)

  • 点积的值没有限制

因此,已经寻求了替代方案,例如点积的归一化版本。归一化点积等同于两个向量之间角度的余弦值,因此称为余弦相似度:

cosΘ=a∙bab=∑i=1Nai×bi∑i=1Nai22∑i=1Nbi22

余弦相似度有一些有趣的特性:

  • 它的值介于 -1 和 1 之间。相反或完全不同的向量将具有 -1 的值,正交向量(或完全不同的散点向量)为 0,完全相似的向量为 1。由于它测量两个向量之间的角度,因此解释更容易,并且在一个特定的范围内,因此它允许人们直观地理解相似性或差异性。

  • 它的计算速度快且成本低。

  • 它对词频不太敏感,因此对异常值更稳健。

  • 它是尺度不变的,这意味着它不受向量大小的影响。

  • 经过归一化处理后,它也可以用于处理高维数据。

对于二维向量,我们可以绘制图表来观察这些属性:

图 1.8 – 两个向量之间余弦相似性的示例

图 1.8 – 两个向量之间余弦相似性的示例

在下一节中,我们可以使用这个相似性的概念来定义我们训练的嵌入的性质。

嵌入的性质

嵌入是一个令人惊讶的灵活方法,并能够编码不同的句法和语义属性,这些属性既可以可视化,也可以用于不同的操作。一旦我们有了相似性的概念,我们就可以搜索与字词 w 最相似的词。请注意,相似性定义为出现在相同的上下文窗口中;模型无法区分同义词和反义词。

此外,该模型还能够表示诸如最高级或动词形式之类的语法关系。

我们可以研究的另一个有趣的关系是类比。平行四边形模型是一个在认知空间中表示类比的系统。经典的例子是 king:queen:👨?(在公式中为 a🅱️:a:?)。鉴于我们有向量,我们可以将其转化为 a-a+b 操作。

我们可以使用我们训练的嵌入模型在 Python 中进行此测试:

  • 我们可以检查最相似的字词。

  • 我们可以测试类比

  • 然后,我们可以测试识别同义词和反义词的能力。

此过程的代码如下:

word_1 = "good"
syn = "great"
ant = "bad"
most_sim =model.wv.most_similar("good")
print("Top 3 most similar words to {} are :{}".format(
    word_1, most_sim[:3]))
synonyms_dist = model.wv.distance(word_1, syn)
antonyms_dist = model.wv.distance(word_1, ant)
print("Synonyms {}, {} have cosine distance: {}".format(
    word_1, syn, synonyms_dist))
print("Antonyms {}, {} have cosine distance: {}".format(
    word_1, ant, antonyms_dist))
a = 'king'
a_star = 'man'
b = 'woman'
b_star= model.wv.most_similar(positive=[a, b], negative=[a_star])
print("{} is to {} as {} is to: {} ".format(
    a, a_star, b, b_star[0][0]))

重要提示

这是我们之前训练的嵌入完成的。注意模型在处理反义词方面并不好。

这种方法并不完全完美,因此有时正确答案不是第一个结果,但它可能是前三个输入之一。此外,该系统适用于文本中频繁出现的实体(如城市名称、常用词),但对于罕见实体则作用甚微。

嵌入还可以作为工具来研究一个词的意义如何随时间变化,特别是如果你有跨越几个十年文本语料库的话。以下图表展示了如何随着时间的推移,字词 gay、broadcast 和 awful 的意义发生了变化:

图 1.9 – 随着年份变化,字词语义意义的二维可视化;这些投影是通过使用来自不同年代的文本和嵌入获得的( https://arxiv.org/abs/1605.09096 )

图 1.9 – 2D 可视化展示了单词的语义意义如何随时间变化;这些投影是通过使用不同年代的文本和嵌入获得的(arxiv.org/abs/1605.09096)

最后,一个单词仍然可以有多个意义!例如,像“good”这样的常用词根据上下文有不同的意义。有人可能会想知道一个单词在嵌入中的向量是否只代表一个意义,或者它是否代表了一个单词的所有意义集合。幸运的是,嵌入向量代表了一个单词各种意义的加权总和(线性叠加)。每个意义的权重与该意义在文本中的频率成正比。尽管这些意义位于同一个向量中,但在计算类比时,我们处理的是这些组成部分。例如,“apple”既是水果,也是一家公司的名字;如果我们进行操作 apple:red:🍌?,我们只是在苹果向量中减去一个非常具体的语义成分(与红色相似的成分)。这种灵活性在我们想要消除歧义时非常有用。此外,由于向量空间是稀疏的,通过利用稀疏编码,我们可以分离出不同的意义:

图 1.10 – 表格展示了 word2vec 中的向量如何同时编码不同的意义 (https://aclanthology.org/Q18-1034/)

图 1.10 – 表格展示了 word2vec 中的向量如何同时编码不同的意义(aclanthology.org/Q18-1034/)

这些向量现在为文本中的每个单词提供了上下文和语义意义。我们可以利用这个丰富的信息源来完成诸如文本分类等任务。我们现在需要的是能够处理文本序列性质的模型,我们将在下一节中学习到这方面的内容。

RNNs,LSTMs,GRUs 和 CNNs 用于文本

到目前为止,我们讨论了如何以模型可消化的方式表示文本;在本节中,我们将讨论在获得表示后如何分析文本。传统上,一旦我们获得了文本的表示,它就会被输入到诸如朴素贝叶斯或甚至逻辑回归等模型中。神经网络的成功使得这些机器学习算法变得过时。在本节中,我们将讨论可用于各种任务的深度学习模型。

RNNs

经典神经网络的缺点是它们没有记忆功能。这对于时间序列和文本输入尤其成问题。在一个单词序列 t 中,时间 t 的单词 w 依赖于时间 t-1 的 w。实际上,在一句话中,最后一个单词通常依赖于句子中的几个单词。因此,我们希望有一个 NN 模型能够记住之前的输入。一个RNN(循环神经网络)维护一个内部状态来保持这种记忆;也就是说,它存储有关先前输入的信息,并且它产生的输出受先前输入的影响。这些网络对序列的所有元素执行相同的操作(因此是循环的)并保持这种操作的内存:

图 1.11 – RNN 的简单示例(img/B21257_01_11.jpg)

图 1.11 – RNN 的简单示例(arxiv.org/pdf/1506.00019)

一个经典的神经网络(前馈神经网络)认为输入是独立的,神经网络的一层对时间 t 的元素表示的向量执行以下操作:

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">y</mml:mi></mml:mrow>mml:mrowmml:mo(</mml:mo>mml:mit</mml:mi>mml:mo)</mml:mo></mml:mrow></mml:msup>mml:mo=</mml:mo>mml:miσ</mml:mi>mml:mo(</mml:mo><mml:mi mathvariant="bold-italic">W</mml:mi>mml:msupmml:mrow<mml:mi mathvariant="bold-italic">x</mml:mi></mml:mrow>mml:mrowmml:mit</mml:mi></mml:mrow></mml:msup>mml:mo+</mml:mo><mml:mi mathvariant="bold-italic">b</mml:mi>mml:mo)</mml:mo></mml:math>

然而,在简单的 RNN 中,以下操作被执行:

at=b+Uht−1+Wxt

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">h</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo=</mml:mo><mml:mi mathvariant="normal">t</mml:mi><mml:mi mathvariant="normal">a</mml:mi><mml:mi mathvariant="normal">n</mml:mi><mml:mi mathvariant="normal">h</mml:mi>mml:mo⁡</mml:mo>mml:mo(</mml:mo>mml:msupmml:mrow<mml:mi mathvariant="bold-italic">a</mml:mi></mml:mrow>mml:mrowmml:mit</mml:mi></mml:mrow></mml:msup>mml:mo)</mml:mo></mml:math>

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">o</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo=</mml:mo><mml:mi mathvariant="bold-italic">c</mml:mi>mml:mo+</mml:mo><mml:mi mathvariant="bold-italic">V</mml:mi>mml:msupmml:mrow<mml:mi mathvariant="bold-italic">h</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup></mml:math>

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">y</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo=</mml:mo>mml:miσ</mml:mi>mml:mo(</mml:mo>mml:msupmml:mrow<mml:mi mathvariant="bold-italic">o</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo)</mml:mo></mml:math>

这些操作看起来可能很复杂,但实际上,我们只是在维护一个考虑先前迭代的隐藏状态。第一个方程是一个普通的正向传播层,其中我们将先前隐藏状态 h 乘以一组权重 U。这个矩阵 U 允许我们控制神经网络如何使用先前上下文来绑定输入和过去输入(过去如何影响时间 t 的输入输出)。在第二个方程中,我们创建一个新的隐藏状态,该状态将被用于后续计算,但也将用于下一个输入。在第三个方程中,我们创建输出;我们使用一个偏置向量和矩阵来计算输出。在最后一个方程中,它简单地作为一个非线性函数传递。

这些 RNN 可以被视为随时间展开的实体,其中我们可以表示整个序列中的网络及其计算:

图 1.12 – RNN 通过序列展开的简单示例(img/B21257_01_12.jpg)

图 1.12 – RNN 通过序列展开的简单示例(arxiv.org/pdf/1506.00019)

我们可以用 PyTorch RNN 在 Python 中测试,看看它是如何转换数据的:

array = np.random.random((10, 5, 3))
# Convert the numpy array to a PyTorch tensor
data_tensor = torch.tensor(array, dtype=torch.float32)
RNN = nn.RNN(input_size=3, hidden_size=10,
             num_layers=1, batch_first=True)
output, hidden = RNN(data_tensor)
output.shape

重要提示

注意模型如何转换数据;我们还可以访问隐藏状态。

我们可以看到几个有趣的事情:

  • RNN 不受输入大小的限制;它是一个在整个序列上进行的循环操作。RNN 基本上一次处理一个单词。这种循环性也意味着反向传播在每个时间步进行。尽管这个模型在序列分析方面表现良好,但其顺序性质不允许它并行化。

  • 理论上,这个模型可以用无限序列的单词进行训练;理论上,经过几个时间步后,它开始忘记初始输入。

  • 训练可能因为梯度消失问题而变得低效,其中梯度必须从最终细胞传播回初始细胞。在这个过程中,它们可以指数级缩小并接近零,使得模型难以学习长距离依赖。相反,梯度爆炸问题也可能发生,其中梯度无控制地变得非常大,导致训练不稳定。

RNN 不是唯一与这个主题相关的深度学习模型形式。

LSTM

理论上,RNN 应该能够处理长序列并记住初始输入。然而,在现实中,隐藏状态中的信息是局部的而不是全局的,对于时间 t,它只考虑前一个时间步而不是整个序列。这种简单模型的主要问题是隐藏状态必须同时履行两个角色:提供与时间 t 的输出相关的信息,并为未来的决策存储记忆。

LSTM 是 RNN 的扩展,其设计理念是模型可以忘记不重要的信息,只保留重要的上下文。

图 1.13 – LSTM 单元的内部结构(img/B21257_01_13.jpg)

图 1.13 – LSTM 单元的内部结构(arxiv.org/pdf/2304.11461)

LSTM 有内部机制来控制层内的信息(门);此外,它还有一个专门上下文层。因此,我们有两个隐藏状态,其中第一个 h 用于时间 t 的信息(短期记忆),另一个 c 用于长期信息。门可以是开启的(1)或关闭的(0);这是通过一个具有 sigmoid 激活的前馈层来实现的,以压缩值在零和一之间。之后,我们使用 Hadamard 积(或逐点乘法)作为层的门控机制。这种乘法作为一个二进制门,当值接近 1 时允许信息通过,当值接近 0 时阻止信息通过。这些门允许一个动态系统,在时间步内,我们决定保留多少信息以及忘记多少信息。

第一个门被称为 遗忘门,因为它用于忘记上下文中不再需要的信息,因此在下一次时间步中也不再需要。所以,我们将使用遗忘门的输出去乘以上下文。此时,我们从输入和前一个时间步的隐藏状态中提取信息。每个门都有一组特定于门的 U 权重:

ft=σ(bf+Ufht−1+Wfxt)

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">k</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo=</mml:mo>mml:msupmml:mrowmml:msupmml:mrow<mml:mi mathvariant="bold-italic">c</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi>mml:mo-</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo⊙</mml:mo><mml:mi mathvariant="bold-italic">f</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup></mml:math>

下一步是从输入中提取信息并决定哪些信息将被添加到上下文中。这由一个输入门 i 控制,它决定了将添加多少信息。上下文随后是通过我们添加的和忘记的内容的总和来获得的:

gt=tanh(bg+Ught−1+Wgxt)

it=σ(bi+Uiht−1+Wixt)

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">j</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo=</mml:mo>mml:msupmml:mrowmml:msupmml:mrow<mml:mi mathvariant="bold-italic">g</mml:mi></mml:mrow>mml:mrowmml:mo(</mml:mo>mml:mit</mml:mi>mml:mo)</mml:mo></mml:mrow></mml:msup>mml:mo⊙</mml:mo><mml:mi mathvariant="bold-italic">i</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup></mml:math>

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">c</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo=</mml:mo>mml:msupmml:mrowmml:msupmml:mrow<mml:mi mathvariant="bold-italic">j</mml:mi></mml:mrow>mml:mrowmml:mo(</mml:mi>t</mml:mi>mml:mo)</mml:mi></mml:mrow></mml:msup>mml:mo+</mml:mo><mml:mi mathvariant="bold-italic">k</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup></mml:math>

最终步骤是计算输出;这是通过一个最终门来实现的。输出或最终层的决策也用于更新隐藏状态:

ot=σ(bo+Uoht−1+Woxt)

<mml:math display="block">mml:msupmml:mrow<mml:mi mathvariant="bold-italic">k</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo=</mml:mo>mml:msupmml:mrowmml:msupmml:mrow<mml:mi mathvariant="bold-italic">o</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup>mml:mo⊙</mml:mo><mml:mi mathvariant="normal">t</mml:mi><mml:mi mathvariant="normal">a</mml:mi><mml:mi mathvariant="normal">n</mml:mi><mml:mi mathvariant="normal">h</mml:mi>mml:mo⁡</mml:mo><mml:mi mathvariant="bold-italic">c</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mit</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msup></mml:math>

这些门控单元相互独立,因此 LSTM 的高效实现可以并行化。我们可以使用 Python 中的 PyTorch RNN 来测试它如何转换数据:

data_tensor = torch.tensor(np.random.random((10, 5, 3)),
                           dtype=torch.float32)
LSTM =nn.LSTM(input_size=3, hidden_size=10,
              num_layers=1, batch_first=True)
output, (hidden, cell) = LSTM(data_tensor)
output.shape

重要注意事项

注意模型如何转换数据;我们可以访问隐藏状态以及细胞状态。

我们还可以注意一些其他有趣的特性:

  • 计算增强是层内进行的,这意味着我们可以轻松地将 LSTMs 替换为 RNN。

  • LSTM 能够长时间保留信息,因为它只保留相关信息,并遗忘不需要的信息。

  • 标准做法是用向量 1 初始化 LSTM(保留一切),然后它自己学习要忘记什么和要添加什么。

  • LSTM 与 RNN 不同,可以记住多达 100 个时间步(RNN 在 7 个时间步之后开始遗忘)。加法运算使得梯度消失或爆炸的可能性降低。

让我们看看另一种计算上更轻量但仍然具有上下文向量概念的模型选项。

GRUs

GRUs是 RNN 的另一种变体,用于解决梯度消失问题,因此它们在记住信息方面更有效。它们与 LSTMs 非常相似,因为它们具有内部门控单元,但它们更简单、更轻量。尽管参数更少,GRUs 的收敛速度比 LSTMs 快,并且仍然可以达到可比的性能。GRUs 利用了使 LSTMs 如此有效的某些元素:加法运算、Hadamard 乘积、上下文的存在以及层内信息控制的机制:

图 1.14 – GRU 单元的内部结构 (https://arxiv.org/pdf/2304.11461)

图 1.14 – GRU 单元的内部结构 (arxiv.org/pdf/2304.11461)

在 GRU 中,遗忘门被称为更新门,但它的目的相同:在更新过程中保留重要信息(接近 1 的值)并重写不重要信息(接近 0 的值)。在 GRU 中,输入门被称为重置门,它不像 LSTM 那样独立,而是与更新门相连。

第一步是更新门z,它实际上与 LSTM 中的遗忘门相同。同时,我们计算重置门r:

zt=σ(bz+Uzht−1+Wzxt)

rt=σ(br+Urht−1+Wrxt)

下一步是更新隐藏状态;这取决于重置门。这样,我们决定将哪些新信息放入隐藏状态,以及保存哪些过去的相关信息。这被称为当前****记忆门:

h‾t=tanh(Whxt+rt⊙Uzht−1)

到目前为止,我们已经有了隐藏状态的最终更新,其中我们也使用了更新门:

ht=zt⊙ht−1+(1−zt)⊙h‾t

我们可以使用 PyTorch RNN 在 Python 中进行测试,以查看它是如何转换数据的:

data_tensor = torch.tensor(np.random.random((10, 5, 3)),
                           dtype=torch.float32)
GRU =nn.GRU(input_size=3, hidden_size=10,
            num_layers=1, batch_first=True)
output, hidden = GRU(data_tensor)
output.shape

重要提示

注意模型是如何转换数据的;我们也可以访问隐藏状态。

我们在这里也可以看到一些有趣的因素:

  • GRU 网络类似于 LSTM 网络,但它们具有参数更少和计算效率更高的优势。但这意味着它们更容易过拟合。

  • 它们可以处理长序列的数据而不会忘记之前的输入。对于许多文本任务(以及语音识别和音乐生成),它们的性能相当不错,尽管在建模长期依赖或复杂模式时,它们不如 LSTMs 高效。

接下来,我们将探讨 CNN。

文本 CNN

CNN被设计用来通过在图像(或其他二维矩阵)上运行滤波器(一个矩阵或核)来寻找其中的模式。卷积是逐像素进行的,滤波器的值与图像中的像素相乘然后求和。在训练过程中,为每个滤波器条目学习一个权重。对于每个滤波器,我们得到一个不同的图像扫描,这可以可视化;这被称为特征图。

卷积网络在计算机视觉中取得了成功,这得益于它们提取局部信息并识别复杂模式的能力。因此,卷积网络被提出用于序列。在这种情况下,使用了一维卷积网络,但原理是相同的。实际上,在序列上,一维卷积用于提取特征图(而不是作为一个二维滤波器或矩阵,我们有一个一维滤波器,它可以被视为 word2vec 的上下文窗口):

图 1.15 – 在一维卷积中,我们正在序列上滑动一个一维滤波器

图 1.15 – 在一维卷积中,我们正在序列上滑动一个一维滤波器

在前面的图中,我们在序列上滚动一个一维滤波器;这个过程非常快,滤波器可以具有任意大小(三到七个单词甚至更多)。模型试图学习在这个核中找到的各种单词之间的模式。它也可以用于从嵌入中获得的向量,我们还可以使用多个核(以便为每个序列学习不同的模式)。与图像 CNN 一样,我们可以添加如最大池化等操作来提取最重要的特征。

我们可以用 Python 中的 PyTorch RNN 来测试,看看它是如何转换数据的:

data_tensor = torch.tensor(np.random.random((10, 5, 3)),
                           dtype=torch.float32)
Conv1d = nn.Conv1d(in_channels=5, out_channels=16,
                   kernel_size=3, stride=1, padding=1)
output = Conv1d(data_tensor)
output.shape

重要提示

注意观察模型是如何转换数据的,以及这与我们之前所看到的不同之处。

现在我们有了将文本转换为数值表示(同时保留上下文信息)的方法,并且有可以处理这种表示的模型,我们可以将它们结合起来以获得端到端系统。

使用嵌入和深度学习进行情感分析

在本节中,我们将训练一个用于对电影评论进行情感分析模型的模型。我们将训练的模型能够将评论分类为正面或负面。为了构建和训练模型,我们将利用我们迄今为止遇到的所有元素。简而言之,我们正在做以下事情:

  • 我们正在预处理数据集,将其转换为数值向量,并使向量和谐

  • 我们正在定义一个带有嵌入的神经网络并对其进行训练

数据集由 50,000 条正面和负面评论组成。我们可以看到它包含不同长度的评论,平均有 230 个单词:

图 1.16 – 显示文本中评论长度分布的图表;左图是正面评论,右图是负面评论

图 1.16 – 显示文本中评论长度分布的图表;左图是正面评论,右图是负面评论

此外,最常出现的词显然是“电影”和“影片”:

图 1.17 – 正面(左图)和负面(右图)评论中最常出现单词的词云

图 1.17 – 正面(左图)和负面(右图)评论中最常出现单词的词云

文本很杂乱,在模型训练之前必须进行清理。第一步是对标签进行二进制编码(“正面”等于 0,“负面”等于 1)。之后,我们将特征和标签(对于数据集中的X是特征,y是标签)分开。接下来,我们创建三个平衡的数据集用于训练、验证和测试:

df['sentiment_encoded'] = np.where(
    df['sentiment']=='positive',0,1)
X,y = df['review'].values, df['sentiment_encoded'].values
x_train,x_test,y_train,y_test = train_test_split(
    X,y,stratify=y, test_size=.2)
x_train,x_val,y_train,y_val = train_test_split(
    x_train,y_train,stratify=y_train, test_size=.1)
y_train, y_val, y_test = np.array(y_train), np.array(y_val), \
    np.array(y_test)

在进行训练之前需要几个步骤:

  • 一个预处理步骤,其中我们移除过多的空格、特殊字符和标点符号。

  • 一个分词步骤,其中我们将各种评论转换为标记。在这个步骤中,我们还移除了停用词和单字符词。对于每个评论,我们只提取最流行的 1000 个单词(这一步骤只是为了在训练期间减少计算时间)。

  • 将单词转换为索引(向量化)以根据我们的词汇表使模型使用数值值。

  • 由于评论长度不同,我们应用填充以使评论长度与固定数字一致(我们这样做是为了训练)。

这些预处理步骤取决于数据集。代码在 GitHub 仓库中。请注意,然而,分词和预处理选择会改变评论的性质——在这种情况下,是摘要统计。

图 1.18 – 显示分词后评论长度分布的图表

图 1.18 – 显示分词后评论长度分布的图表

我们正在定义模型及其超参数。在这种情况下,我们正在训练一个神经网络来预测由嵌入和 GRUs 组成的情感数据。为了使训练更稳定,我们添加了正则化(dropout)。线性层是将我们提取的特征映射到单个表示。我们使用这个表示来计算评论是正面还是负面的概率:

# Hyperparameters
no_layers = 3
vocab_size = len(vocab) + 1  # extra 1 for padding
embedding_dim = 300
output_dim = 1
hidden_dim = 256
# Initialize the model
model = SentimentRNN(no_layers, vocab_size, hidden_dim,
                     embedding_dim, drop_prob=0.5)

注意,在这种情况下,我们使用二元交叉熵损失,因为我们只有两个类别(正面和负面)。此外,我们使用Adam作为优化器,但也可以测试其他优化器。在这种情况下,我们进行批量训练,因为我们有成千上万的评论:

criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
epoch_tr_loss, epoch_vl_loss = [], []
epoch_tr_acc, epoch_vl_acc = [], []
for epoch in range(epochs):
    train_losses = []
    train_acc = 0.0
    model.train()
    h = model.init_hidden(50)
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        h = h.data
        model.zero_grad()
        output, h = model(inputs, h)
        loss = criterion(output.squeeze(), labels.float())
        loss.backward()
        train_losses.append(loss.item())
        accuracy = acc(output, labels)
        train_acc += accuracy
        optimizer.step()

下面的图表显示了训练集和验证集的准确率和损失:

图 1.19 – 训练集和验证集的准确率和损失训练曲线

图 1.19 – 训练集和验证集的准确率和损失训练曲线

从下面的混淆矩阵中我们可以看到,模型达到了良好的准确率:

图 1.20 – 测试集的混淆矩阵

图 1.20 – 测试集的混淆矩阵

此外,如果我们观察训练前后评论的投影,我们可以看到模型已经学会了如何区分正面和负面评论:

图 1.21 – 模型训练前后(左图)和训练后(右图)获得的嵌入投影

图 1.21 – 模型训练前后(左图)和训练后(右图)获得的嵌入投影

我们现在已经训练了一个模型,它可以接受纯文本评论并将其分类为正面或负面。我们通过结合本章中看到的前述元素来实现这一点。同样的方法可以应用于任何其他数据集;这就是深度学习的力量。

摘要

在本章中,我们看到了如何将文本转换为越来越复杂的向量表示。这种文本的数值表示使我们能够使用机器学习模型。我们看到了如何保留文本的上下文信息(词嵌入),以及如何将这些信息用于后续分析(例如,搜索同义词或聚类单词)。此外,我们还看到了如何使用神经网络(RNNs、LSTM、GRUs)来分析文本并执行任务(例如,情感分析)。

在下一章中,我们将看到如何解决一些尚未解决的挑战,并看到这将如何导致这里看到的模型的自然进化。

第二章:Transformer:现代人工智能革命的模型背后的秘密

在本章中,我们将讨论上一章中看到的模型的局限性,以及如何通过新的范式(首先是注意力机制,然后是 transformer)来解决这些局限性。这将使我们能够理解这些模型是如何训练的,以及为什么它们如此强大。我们将讨论为什么这个范式是成功的,以及为什么它使得解决以前不可能的自然语言处理(NLP)任务成为可能。然后我们将看到这些模型在实际应用中的能力。

本章将阐明为什么当代的 LLM(大型语言模型)本质上基于 transformer 架构。

在本章中,我们将讨论以下主题:

  • 探索注意力机制和自注意力

  • 介绍 transformer 模型

  • 训练一个 transformer

  • 探索掩码语言模型

  • 可视化内部机制

  • 应用 transformer

技术要求

大部分代码可以在 CPU 上运行,但某些部分(微调和知识蒸馏)更适宜在 GPU 上运行(在 CPU 上训练一小时与在 GPU 上不到五分钟相比)。

代码是用 PyTorch 编写的,大部分使用标准库(PyTorch、Hugging Face Transformers 等),尽管一些片段来自 Ecco,一个特定的库。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr2

探索注意力机制和自注意力

在 20 世纪 50 年代,随着计算机革命的开始,政府开始对机器翻译的想法产生兴趣,尤其是军事应用方面。这些尝试都以失败告终,主要原因有三个:机器翻译比看起来更复杂,计算能力不足,数据也不足。政府在 20 世纪 60 年代得出结论,这是一个技术上不可能的挑战。

到了 20 世纪 90 年代,三个限制中的两个开始被克服:互联网最终允许有大量的文本,GPU 的出现最终允许计算能力。第三个要求仍然需要满足:一个能够利用新发现的计算能力来处理自然语言复杂性的模型。

机器翻译吸引了研究者的兴趣,因为它是一个易于评估结果的实际问题(我们可以很容易地判断翻译是否好)。此外,我们有一种语言的大量文本和另一种语言的对应文本。因此,研究人员试图将先前模型适应到任务(RNN、LSTM 等)中。最常用的系统是seq2seq 模型,其中包含一个编码器和一个解码器。编码器将序列转换成一种新的简洁表示,应该保留相关信息(一种良好的摘要)。解码器接收这个上下文向量作为输入,并使用它来转换(翻译)这个输入为输出。

图 2.1 – 带有编码器和解码器的 seq2seq 模型。在一种情况下,我们取隐藏状态的平均值(左);在另一种情况下,我们使用注意力机制来识别哪个隐藏状态对翻译更相关(右)

图 2.1 – 带有编码器和解码器的 seq2seq 模型。在一种情况下,我们取隐藏状态的平均值(左);在另一种情况下,我们使用注意力机制来识别哪个隐藏状态对翻译更相关(右)

RNN 及其衍生模型存在一些问题:

  • 对齐:输入和输出的长度可以不同(例如,将英语翻译成法语“她不喜欢土豆”翻译成“她不喜欢苹果 土豆”)。

  • 梯度消失和梯度爆炸:在训练过程中出现的问题,使得多层无法有效管理。

  • 不可并行性:训练计算成本高且不可并行。RNN 在几步之后就会忘记。

图 2.2 – 对齐问题的示例:一对一(左)和虚假词(右)

图 2.2 – 对齐问题的示例:一对一(左)和虚假词(右)

注意力机制最初被描述为解决对齐问题,以及学习文本的各个部分与相应翻译文本部分之间的关系。

理念是,我们不是传递 RNN 的隐藏状态,而是传递只关注序列重要部分的上下文信息。在解码(翻译)每个标记时,我们希望检索另一种语言中对应和具体的信息。注意力机制确定在那一刻输入中哪些标记是重要的。

第一步是编码器(h)的隐藏状态和前一个解码器输出(s)之间的对齐。得分函数可以不同:点积或余弦相似度是最常用的,但也可以是更复杂的函数,例如前馈神经网络层。这一步使我们能够理解在那一刻隐藏状态编码器与翻译的相关性。这一步会对所有编码器步骤进行。

1ei,j=score(si−1,hj)

目前,我们有一个表示两个向量(h 和 s)之间相似度的标量。所有这些分数都传递到 softmax 函数中,该函数将所有值压缩到 0 和 1 之间。这一步也用于为每个隐藏状态分配相对重要性。

2ai,j=softmaxei,j=exp(ei,j)∑k=1texp(ei,k)

最后,我们对各种隐藏状态进行加权求和,乘以注意力分数。因此,我们有一个固定长度的上下文向量,能够提供关于整个隐藏状态集的信息。简单来说,在翻译过程中,我们有一个动态更新的上下文向量,告诉我们应该对输入序列的每个部分给予多少注意力。

3ct=∑j=1Tai,j∙hj

如原文所示,模型在翻译过程中对输入中的不同单词给予不同的注意力。

图 2.3 – 使用注意力训练模型后的句子对齐示例。每个像素显示源词和目标词之间的注意力权重。

图 2.3 – 使用注意力训练模型后的句子对齐示例。每个像素显示源词和目标词之间的注意力权重。arxiv.org/pdf/1409.0473

除了解决对齐问题外,注意力机制还有其他优点:

  • 它减少了梯度消失问题,因为它提供了一个通往早期状态的捷径。

  • 它消除了瓶颈问题;编码器可以直接在翻译中访问源。

  • 它还提供了可解释性,因为我们知道哪些词用于对齐。

  • 它无疑提高了模型的性能。

它的成功催生了几个变体,其中评分函数不同。特别是其中一个变体,称为自注意力,具有特别的优势,即它可以直接从输入中提取信息,而不必一定需要与其他东西进行比较。

自注意力的背后洞察是,如果我们想在图书馆(查询)寻找一篇关于法国大革命的论文,我们不需要阅读所有书籍来找到关于法国历史的书籍(值),我们只需要阅读书籍的边缘(键)。换句话说,自注意力是一种允许我们在上下文中搜索以找到所需表示的方法。

图 2.4 – 自注意力机制。包括矩阵维度;数字是任意的

图 2.4 – 自注意力机制。包括矩阵维度;数字是任意的

对于模型来说,给定一个输入,我们想要在序列的各种组件(如标记)之间进行一系列比较以获得输出序列(然后我们可以将其用于各种模型或任务)。自注意力方程如下:

AttentionQ,K,V=softmaxQ∙kTdk∙V

你可以立即看出,它是从原始注意力公式派生出来的。我们使用点积来进行比较,然后利用softmax函数来计算相对重要性和将值归一化到 0 和 1 之间。D是序列的大小;换句话说,自注意力也是作为我们序列长度的函数进行归一化的。

下一步是使用softmax。这里是对该函数(如何计算以及如何在 Python 中更高效地实现)的一个小复习:

y=exi∑i=1i=nexi

python:y=y1y2y3=softmaxx=fx1x2x3=x1x2x3ex1+ex2+ex3=exsum(ex)

正如我们在上一章中看到的,随着向量长度的增加,点积可以变得相当宽。这可能导致softmax函数中的输入太大(这会将softmax中的概率质量转移到几个元素上,从而导致梯度很小)。在原始文章中,他们通过将D的平方根进行归一化来解决此问题。

![图 2.5 – 展开的自我注意力图 2.5 – 展开的自我注意力真正的区别在于我们使用三个初始随机初始化的权重矩阵:查询(`Q`)、键(`K`)和值(`V`)。`Q`是当前注意力的焦点,`K`向模型提供关于先前输入的信息,而`V`用于提取最终输入信息。因此,第一步是将这三个矩阵与我们的输入`X`(一个向量数组,其中每个向量代表一个标记)相乘。`Q=X∙WQ,K=X∙WV,V=X∙WV这个系统的美妙之处在于我们可以用它从相同的输入中提取多个表示(毕竟,教科书里可以有多个问题)。因此,由于操作可以并行化,我们可以有多头注意力。多头自注意力使得模型能够同时捕捉输入序列中多种类型的关系。这一点至关重要,因为句子中的一个词在上下文中可能与几个其他词相关。在训练过程中,每个头中的`K`和`Q`矩阵专门用于建模不同类型的关系。每个注意力头根据其特定的视角产生输出,从而为`n`个头生成`n`个输出。然后,这些输出被连接起来,并通过最终的线性投影层恢复到原始输入的大小。图 2.6 – 多头自注意力

图 2.6 – 多头自注意力

自注意力机制具有几个优点:

  • 我们可以为每个输入提取不同的表示。

  • 我们可以在 GPU 上并行执行所有这些计算。每个头可以独立计算。

  • 我们可以在不必要包含编码器和解码器的模型中使用它。

  • 我们不必等待不同时间步来看到远距离词对之间的关系(如在 RNN 中)。

  • 然而,它在函数上具有与标记数N的二次成本,并且没有固有的顺序概念。

自注意力在计算上很昂贵。可以证明,考虑到序列T和序列长度d,计算成本和空间是二次的:

`time=OT2+dspace=O(T2+Td)

他们将点积识别为罪魁祸首。这种计算成本是可扩展性问题之一(考虑到多头注意力在每个块中计算)。因此,已经提出了许多自注意力的变体来降低计算成本。

尽管计算成本较高,但自注意力已经显示出其能力,尤其是在堆叠多层时。在下一节中,我们将讨论这如何使模型尽管计算成本高,但仍然非常强大。

介绍 Transformer 模型

尽管有这个决定性的进步,但在机器翻译中仍存在几个问题:

  • 模型未能捕捉句子的含义,并且仍然存在错误倾向

  • 此外,我们还有初始词汇表中没有的单词的问题

  • 代词和其他语法形式中的错误

  • 模型未能维持长文本的上下文

  • 如果训练集和测试数据中的领域不同(例如,如果它在文学文本上训练,而测试集是金融文本),则不可适应

  • RNN 不可并行化,必须按顺序计算

考虑到这些点,2016 年谷歌研究人员提出了完全消除 RNN 而不是改进它们的想法。根据《注意力即一切》开创性文章的作者;你所需要的是一个基于多头自注意力的模型。在详细说明之前,Transformer 模型完全由堆叠的多头自注意力层组成。通过这种方式,模型学习到文本的分层和越来越复杂的表示。

该过程的第一步是将文本转换为数值向量(分词)。之后,我们有一个嵌入步骤来获取每个标记的向量。Transformer 的一个特殊功能是引入一个函数来记录序列中每个标记的位置(自注意力不是位置感知的)。这个过程被称为位置编码。文章中的作者使用正弦和余弦函数交替使用位置。这使得模型能够知道每个标记的相对位置。

<mml:math display="block">mml:msubmml:mrowmml:miP</mml:mi>mml:miE</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mip</mml:mi>mml:mio</mml:mi>mml:mis</mml:mi>mml:mo,</mml:mo>mml:mn2</mml:mn>mml:mii</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:msub>mml:mo=</mml:mo><mml:mi mathvariant="normal">s</mml:mi><mml:mi mathvariant="normal">i</mml:mi><mml:mi mathvariant="normal">n</mml:mi>mml:mo(</mml:mo>mml:mip</mml:mi>mml:mio</mml:mi>mml:mis</mml:mi>mml:mo/</mml:mo>mml:msupmml:mrowmml:mn1000</mml:mn></mml:mrow>mml:mrowmml:mn2</mml:mn>mml:mii</mml:mi>mml:mo/</mml:mo>mml:mid</mml:mi></mml:mrow></mml:msup>mml:mo)</mml:mo></mml:math>

<mml:math display="block">mml:msubmml:mrowmml:miP</mml:mi>mml:miE</mml:mi></mml:mrow>mml:mrow<mml:mfenced separators="|">mml:mrowmml:mip</mml:mi>mml:mio</mml:mi>mml:mis</mml:mi>mml:mo,</mml:mo>mml:mn2</mml:mn>mml:mii</mml:mi>mml:mo+</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:mfenced></mml:mrow></mml:msub>mml:mo=</mml:mo><mml:mi mathvariant="normal">c</mml:mi><mml:mi mathvariant="normal">o</mml:mi><mml:mi mathvariant="normal">s</mml:mi>mml:mo(</mml:mo>mml:mip</mml:mi>mml:mio</mml:mi>mml:mis</mml:mi>mml:mo/</mml:mo>mml:msupmml:mrowmml:mn1000</mml:mn></mml:mrow>mml:mrowmml:mn2</mml:mn>mml:mii</mml:mi>mml:mo/</mml:mo>mml:mid</mml:mi></mml:mrow></mml:msup>mml:mo)</mml:mo></mml:math>

在第一步中,嵌入向量与这些函数的结果相加。这是因为自注意力不知道词序,但一个句子中的词序很重要。因此,顺序直接编码在它等待的向量中。注意,然而,这个函数中没有可学习的参数,并且对于长序列,它将需要修改(我们将在下一章讨论这个问题)。

图 2.7 – 位置编码

图 2.7 – 位置编码

之后,我们按顺序有一系列变换器模块。变换器模块由四个元素组成:多头自注意力、前馈层、残差连接和层归一化。

图 2.8 – 变换器模块的流程图

图 2.8 – 变换器模块的流程图

前馈层由两个线性层组成。这一层用于获取多头自注意力的线性投影。权重对于每个位置都是可识别的,并且是分开的。它可以看作是两个线性变换,中间有一个 ReLU 激活。

<mml:math display="block">mml:miF</mml:mi>mml:miF</mml:mi>mml:miN</mml:mi><mml:mfenced separators="|">mml:mrowmml:mix</mml:mi></mml:mrow></mml:mfenced>mml:mo=</mml:mo><mml:mi mathvariant="normal">m</mml:mi><mml:mi mathvariant="normal">a</mml:mi><mml:mi mathvariant="normal">x</mml:mi>mml:mo⁡</mml:mo>mml:mo(</mml:mo>mml:mn0</mml:mn>mml:mo,</mml:mo>mml:mix</mml:mi>mml:msubmml:mrowmml:miW</mml:mi></mml:mrow>mml:mrowmml:mn1</mml:mn></mml:mrow></mml:msub>mml:mo+</mml:mo>mml:msubmml:mrowmml:mib</mml:mi></mml:mrow>mml:mrowmml:mn1</mml:mn></mml:mrow></mml:msub>mml:mo)</mml:mo>mml:msubmml:mrowmml:miW</mml:mi></mml:mrow>mml:mrowmml:mn2</mml:mn></mml:mrow></mml:msub>mml:mo+</mml:mo>mml:msubmml:mrowmml:mib</mml:mi></mml:mrow>mml:mrowmml:mn2</mml:mn></mml:mrow></mml:msub></mml:math>

这为自注意力添加了一个非线性步骤。选择 FFN 层是因为它是一个易于并行化的操作。

剩余连接是两种层之间传递信息而不经过中间层变换的连接。最初在卷积网络中开发,它们允许层之间有捷径,并帮助梯度向下传递到较低层。在 Transformer 中,存在注意层和前馈的块,其中输入与输出相加。剩余连接还有使损失表面更平滑的优势(这有助于模型找到更好的最小值,而不会陷入局部损失)。这种强大的效果在图 2.9中可以清楚地看到:

图 2.9 – 剩余连接对损失的影响

图 2.9 – 剩余连接对损失的影响

注意

图 2.9最初来自 Hao Li、Zheng Xu、Gavin Taylor、Christoph Studer 和 Tom Goldstein 的《可视化神经网络损失景观》(github.com/tomgoldstein/loss-landscape/tree/master)。

剩余连接使损失表面更平滑,这允许模型更高效、更快速地训练。

层归一化是一种归一化形式,它有助于训练,因为它保持隐藏层值在某个范围内(它是批归一化的替代方案)。在取了一个单向量之后,它通过利用均值和标准差的过程进行归一化。计算了均值和标准差后,向量被缩放:

μ=1d∑i=1dxiσ=1d∑i=1d(xi−μ)2

xˆ=(x−μ)σ

在最终的转换中,我们利用了训练期间学习的两个参数。

LayerNormalization=γxˆ+β

训练过程中有很多可变性,这可能会损害训练学习。为了减少无信息可变性,我们添加了这个归一化步骤,从而也归一化了梯度。

在这一点上,我们可以将所有内容组装成一个单独的块。考虑在嵌入之后,我们输入 X 是一个维度为 n x d 的矩阵(其中 n 是标记的数量,d 是嵌入的维度)。这个输入 X 进入转换器块,并以相同的维度输出。这个过程会重复应用于所有转换器块:

<mml:math display="block"><mml:mi mathvariant="bold-italic">H</mml:mi>mml:mo=</mml:mo>mml:miL</mml:mi>mml:mia</mml:mi>mml:miy</mml:mi>mml:mie</mml:mi>mml:mir</mml:mi>mml:miN</mml:mi>mml:mio</mml:mi>mml:mir</mml:mi>mml:mim</mml:mi><mml:mfenced separators="|">mml:mrow<mml:mi mathvariant="bold-italic">X</mml:mi>mml:mo+</mml:mo>mml:miM</mml:mi>mml:miu</mml:mi>mml:mil</mml:mi>mml:mii</mml:mi>mml:miH</mml:mi>mml:mie</mml:mi>mml:mia</mml:mi>mml:mid</mml:mi>mml:miS</mml:mi>mml:mie</mml:mi>mml:mil</mml:mi>mml:mif</mml:mi>mml:miA</mml:mi>mml:mit</mml:mi>mml:mit</mml:mi>mml:mie</mml:mi>mml:min</mml:mi>mml:mii</mml:mi>mml:min</mml:mi>mml:mio</mml:mi>mml:min</mml:mi><mml:mfenced separators="|">mml:mrow<mml:mi mathvariant="bold-italic">X</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:mfenced></mml:math>

<mml:math display="block"><mml:mi mathvariant="bold-italic">H</mml:mi>mml:mo=</mml:mo>mml:miL</mml:mi>mml:mia</mml:mi>mml:miy</mml:mi>mml:mie</mml:mi>mml:mir</mml:mi>mml:miN</mml:mi>mml:mio</mml:mi>mml:mir</mml:mi>mml:mim</mml:mi><mml:mfenced separators="|">mml:mrow<mml:mi mathvariant="bold-italic">H</mml:mi>mml:mo+</mml:mo>mml:miF</mml:mi>mml:miF</mml:mi>mml:miN</mml:mi><mml:mfenced separators="|">mml:mrow<mml:mi mathvariant="bold-italic">H</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:mfenced></mml:math>

关于此过程的几点说明如下:

  • 在某些架构中,层归一化可以放在 FFN 块之后而不是之前(是否更好仍在讨论中)。

  • 现代模型串联的转换器块最多可达 96 个,但结构实际上完全相同。其理念是模型学习语言越来越复杂的表示。

  • 从输入的嵌入开始,自注意力允许通过结合越来越复杂的上下文来丰富这种表示。此外,模型还了解每个标记的位置信息。

  • 绝对位置编码的缺陷是过度表示序列开头的单词。今天,有考虑相对位置的变体。

一旦我们有了“积木”,我们就可以将它们组装成一个功能结构。在原始描述中,该模型是为机器翻译而设计的,由两部分组成:一个编码器(它接受要翻译的文本)和一个解码器(它将生成翻译)。

原始的转换器由编码器和解码器中的不同转换器块和结构组成,如图 2.10 所示。

图 2.10 – 编码器-解码器结构

图 2.10 – 编码器-解码器结构

解码器,就像编码器一样,由嵌入层、位置编码器和一系列的 Transformer 块组成。有一点需要注意的是,在解码器中,我们不是使用自注意力,而是使用交叉注意力。交叉注意力完全相同,只是我们同时从编码器和解码器中取两个元素(因为我们希望解码器的生成基于编码器输入)。在这种情况下,查询来自编码器,其余来自解码器。正如你从图 2.11 中可以看到的,解码器序列可以有不同的长度,但结果是一样的:

图 2.11 – 交叉注意力

图 2.11 – 交叉注意力

输入N来自编码器,而输入M来自解码器。在图中,交叉注意力正在混合编码器和解码器中的信息,使解码器能够从编码器中学习。

关于结构的另一个注意事项:在解码器中,第一个自注意力机制有一个额外的遮蔽层,以防止模型看到未来的信息。

这在 QT 的情况下尤其如此。事实上,如果想要预测下一个单词,而模型已经知道它是什么,我们就有了数据泄露。为了补偿这一点,我们添加了一个遮蔽层,其中上三角部分被替换为负无穷大:- ∞。

图 2.12 – 遮蔽注意力

图 2.12 – 遮蔽注意力

第一个 Transformer 由一个编码器和解码器组成,但今天也有模型要么只有编码器,要么只有解码器。今天,对于生成式 AI,它们实际上都是只有解码器。我们有了我们的模型;现在,如何训练这样一个看似复杂的系统呢?在下一节中,我们将看到如何成功地进行训练。

训练一个 Transformer

你如何训练这样一个复杂的模型?这个问题的答案比你想象的要简单。模型可以通过多头自注意力学习复杂且多样化的关系,这使得模型能够灵活地学习复杂的模式。构建示例(或找到它们)来教模型这些复杂关系会非常昂贵。因此,我们希望有一个系统,允许模型自己学习这些关系。优势在于,如果我们有大量的文本可用,模型可以在我们不需要精心挑选训练语料库的情况下进行学习。多亏了互联网的出现,我们有了大量语料库,允许模型看到不同主题、语言、风格等的文本示例。

尽管原始模型是一个seq2seq模型,但后来的转换器(如 LLMs)被训练成语言模型,尤其是在自监督方式下。在语言建模中,我们考虑一个单词序列 s,序列中下一个单词 x 的概率是 mml:mathmml:miP</mml:mi>mml:mo(</mml:mo>mml:miw</mml:mi>mml:mo|</mml:mo>mml:mih</mml:mi>mml:mo)</mml:mo></mml:math>。这个概率取决于该点之前的所有单词。通过概率的链式法则,我们可以分解这个概率:

<mml:math display="block">mml:miP</mml:mi><mml:mfenced separators="|">mml:mrowmml:miw</mml:mi></mml:mrow>mml:mrowmml:mih</mml:mi></mml:mrow></mml:mrow><mml:mfenced separators="|">mml:mrowmml:miP</mml:mi></mml:mrow>mml:mrowmml:msubmml:mrowmml:miw</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:msub></mml:mrow>mml:mrowmml:msubmml:mrowmml:miw</mml:mi></mml:mrow>mml:mrowmml:mn1</mml:mn>mml:mo:</mml:mo>mml:min</mml:mi>mml:mo-</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:msub></mml:mrow></mml:mfenced>mml:mo=</mml:mo>mml:mrowmml:munderover<mml:mo stretchy="false">∏</mml:mo>mml:mrowmml:mii</mml:mi>mml:mo=</mml:mo>mml:mn1</mml:mn></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:munderover>mml:mrowmml:miP</mml:mi><mml:mfenced separators="|">mml:mrowmml:msubmml:mrowmml:miw</mml:mi></mml:mrow>mml:mrowmml:mii</mml:mi></mml:mrow></mml:msub></mml:mrow>mml:mrowmml:msubmml:mrowmml:miw</mml:mi></mml:mrow>mml:mrowmml:mn1</mml:mn>mml:mo:</mml:mo>mml:mii</mml:mi>mml:mo-</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:msub></mml:mrow></mml:mfenced></mml:mrow></mml:mrow></mml:math>

这使我们能够计算从一系列先前单词中一个单词的条件概率。其理念是,当我们拥有足够的文本时,我们可以将诸如“to be or not to”这样的序列作为输入,并让模型估计下一个单词为“be”的概率,即 <mrow><mrow><mrow><mi>P</mi><mo>(</mo><mi>b</mi><mi>e</mi><mo>|</mo><mi>t</mi><mi>o</mi><mi>b</mi><mi>e</mi><mi>o</mi><mi>r</mi><mi>n</mi><mi>o</mi><mi>t</mi><mi>t</mi><mi>o</mi><mo>)</mo></mrow></mrow></mrow>. 然后,在 transformer 块序列之后,我们有一个执行线性投影的层和一个生成输出的softmax 层。之前的序列被称为上下文;第一个 transformer 的上下文长度为 512 个标记。模型生成一个输出,这是一个维度为V(模型词汇表)的概率向量,也称为logit 向量。投影层被称为unembedder(它执行反向映射),因为我们必须从N标记 x D嵌入维度映射到 1 x V。由于每个 transformer 块的输入和输出相同,理论上我们可以消除块,并将 unembedder 和 softmax 附加到任何中间块上。这使我们能够更好地解释每个块的功能及其内部表示。

一旦我们有了这个概率向量,我们就可以使用自监督进行训练。我们取一个文本语料库(未标注)并训练模型以最小化序列中真实单词的概率与预测概率之间的差异。为此,我们使用交叉熵损失(预测概率分布与真实概率分布之间的差异)。预测概率分布是 logit 向量,而真实的一个是 one-hot 编码向量,其中序列中的下一个单词为 1,其他地方为 0。

<mml:math display="block"><mml:msub><mml:mrow><mml:mi>L</mml:mi></mml:mrow><mml:mrow><mml:mi>C</mml:mi><mml:mi>E</mml:mi></mml:mrow></mml:msub><mml:mo>=</mml:mo><mml:mo>-</mml:mo><mml:mrow><mml:munder><mml:mo stretchy="false">∑</mml:mo><mml:mrow><mml:mi>w</mml:mi><mml:mo>∈</mml:mo><mml:mi>V</mml:mi></mml:mrow></mml:munder><mml:mrow><mml:msub><mml:mrow><mml:mi>y</mml:mi></mml:mrow><mml:mrow><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mfenced close="]" open="[" separators="|"><mml:mrow><mml:mi>w</mml:mi></mml:mrow></mml:mfenced><mml:mi>l</mml:mi><mml:mi>o</mml:mi><mml:mi>g</mml:mi><mml:msub><mml:mrow><mml:mover accent="true"><mml:mrow><mml:mi>y</mml:mi></mml:mrow><mml:mo>^</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mo>[</mml:mo><mml:mi>w</mml:mi><mml:mo>]</mml:mo></mml:mrow></mml:mrow></mml:math>

在实践中,训练过程中只是简单地计算实际预测单词的概率和 1 之间的差异。这个过程对序列中的每个单词都是迭代的(称为教师强制)。最终的损失是整个序列的平均值。

图 2.13 – transformer 的训练;损失是所有时间步长的平均损失

图 2.13 – transformer 的训练;损失是所有时间步长的平均损失

由于所有计算都可以在 transformer 中并行进行,我们不需要逐词计算,而是将整个序列输入到模型中。

一旦我们得到了一个概率向量,我们可以选择概率最高的(贪婪解码)。贪婪解码形式上定义为在每个时间步选择概率最高的标记:

<mml:math display="block"><mml:msub><mml:mrow><mml:mi>w</mml:mi></mml:mrow><mml:mrow><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mo>=</mml:mo><mml:msub><mml:mrow><mml:mi>a</mml:mi><mml:mi>r</mml:mi><mml:mi>g</mml:mi><mml:mi>m</mml:mi><mml:mi>a</mml:mi><mml:mi>x</mml:mi></mml:mrow><mml:mrow><mml:mi>w</mml:mi><mml:mo>∈</mml:mo><mml:mi>V</mml:mi></mml:mrow></mml:msub><mml:mi>P</mml:mi><mml:mo>(</mml:mo><mml:mi>w</mml:mi><mml:mo>|</mml:mo><mml:msub><mml:mrow><mml:mi>w</mml:mi></mml:mrow><mml:mrow><mml:mo><</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mo>)</mml:mo></mml:math>

事实上,它已经不再使用了,因为结果太可预测、太通用和太重复。因此,使用更复杂且确定性较低的采样方法。这个过程被称为解码(或自回归生成或因果语言建模,因为它是从先前的单词选择中派生出来的)。这个系统的最简单版本是基于生成最多预定的序列长度文本,或者直到选择一个句子结束标记(<EOS>)。

我们需要找到一种方法,在平衡质量和多样性的同时选择标记。一个总是选择相同单词的模型肯定会具有更高的质量,但也会很重复。有几种不同的采样方法:

  • 随机采样:模型随机选择下一个标记。句子看起来很奇怪,因为模型选择了罕见或独特的单词。

  • Top-k 采样:在每一步,我们对概率进行排序,并选择概率最高的k个单词。我们重新归一化概率并随机选择一个。

  • Top-p 采样:这是一种替代方案,我们只保留最可能单词的一定百分比。

  • softmax,我们将除以一个温度参数(介于 0 和 1 之间)。当t越接近 0 时,最可能单词的概率就越接近 1(接近贪婪采样)。在某些情况下,当我们想要一个不那么贪婪的方法时,t也可以大于 1。

到目前为止,我们考虑了固定词汇,并假设每个标记都是一个单词。一般来说,一旦模型训练完成,可能会有一些模型不知道的单词,这些单词被分配了一个特殊的标记<UNK>。在之后的 transformers 和 LLMs 中,寻求了一种解决未知词问题的方法。例如,在训练集中,我们可能有诸如big、bigger和small这样的单词,但没有smaller。模型不会知道smaller,会导致<UNK>。根据训练集,模型可能有不完整或过时的知识。在英语和其他语言中,都有确切的词素和语法规则,我们希望分词器能够意识到这一点。为了避免出现太多的<UNK>,一种解决方案是从子词(标记)的角度思考。

最常用的方法是字节对编码(BPE)。这个过程从一组单个字符开始。算法随后扫描整个语料库,并开始合并最频繁一起出现的符号。例如,我们有E和R,在第一次扫描后,我们向词汇表中添加一个新的ER符号。这个过程会迭代地进行,合并并创建新的符号(越来越长的字符字符串)。通常,算法会在创建了N个标记(N是开始时预定的一个数字)后停止。此外,还有一个特殊的单词结束符号,用于区分标记是在单词内部还是单词的末尾。一旦算法到达创建词汇表,我们就可以使用分词器对语料库进行分词,并为每个子词分配一个与词汇表中索引相对应的索引。

图 2.14 – 分词结果的示例

图 2.14 – 分词结果的示例

这种方法通常会导致常见词汇出现在模型词汇表中,而罕见词汇则被分割成子词。此外,模型还会学习后缀和前缀,并考虑app和app#子词之间的区别,代表一个完整的单词和一个子词(app#是application的子词)。

探索掩码语言建模

尽管 transformer 具有革命性,但 transformer 在科学界的普及也归功于双向编码器表示的 Transformer(BERT)模型。这是因为 BERT 是 transformer 的一个革命性变体,展示了这种类型模型的能力。BERT 之所以革命性,是因为它已经前瞻性地专门为未来的应用(如问答、摘要和机器翻译)进行了设计。事实上,原始的 transformer 分析的是从左到右的序列,所以当模型遇到一个实体时,它不能将其与实体右侧的内容联系起来。在这些应用中,从两个方向获取上下文非常重要。

图 2.15 – 因果语言模型和双向语言模型之间的差异

图 2.15 – 因果语言模型和双向语言模型之间的差异

双向编码器通过允许模型在整个序列中找到关系来解决这个问题。显然,我们不能再使用语言模型来训练它(当你已经知道答案时,识别序列中的下一个词将变得非常容易),但我们必须找到一种方法来训练双向模型。为了澄清,模型一次性读取整个序列,在这种情况下,只包含编码器。

为了尽量减少对结构的改变,我们使用所谓的<MASK>。在原始训练中,他们随机遮蔽了 15%的标记。请注意,在这种情况下,我们没有遮蔽未来,因为我们希望模型意识到整个上下文。此外,为了更好地分隔不同的句子,我们有一个特殊的标记[CLS],它表示输入的开始,以及[SEP]来分隔输入中的句子(例如,如果我们有一个问题和答案)。否则,结构是相同的:我们有一个嵌入器、位置编码器、不同的 transformer 块、线性投影和 softmax。损失的计算方式相同;我们不是使用下一个标记,而是使用遮蔽标记。原始文章介绍了 BERT 的两个版本:BERT-BASE(12 层,隐藏大小为 d=768,12 个注意力头,总参数为 110M)和 BERT-LARGE(24 层,隐藏大小为 d=1024,24 个注意力头,总参数为 340M)。

MLM 是一种灵活的方法,因为其理念是破坏输入并要求模型重建。我们可以进行遮蔽,也可以重新排序或进行其他转换。这种方法的缺点是只有 15%的标记实际上被用于学习,因此模型效率非常高。

训练也非常灵活。例如,模型可以扩展到句子之间的[SEP]标记。最后一层是用于句子分类的 softmax;我们考虑类别的损失。这显示了系统的灵活性,可以适应不同的任务。

最后再澄清一点。直到 2024 年,人们一直认为这些模型无法生成文本。在 2024 年,两项研究表明,通过调整模型,即使使用 BERT 类似的模型也可以生成文本。例如,在这项研究中,他们展示了通过利用一系列标记可以生成文本。

图 2.16 – 使用 MLM 进行文本生成)(img/B21257_02_16.jpg)

图 2.16 – 使用 MLM 进行文本生成(arxiv.org/pdf/2406.04823)

现在我们已经看到了 transformer 的两种主要训练类型,我们可以更好地探索这些模型内部发生的事情。

可视化内部机制

我们已经看到了 transformer 的内部工作原理,以及它是如何被训练的,以及主要模型类型。注意力的美妙之处在于我们可以可视化这些关系,在本节中,我们将看到如何做到这一点。然后,我们可以可视化 BERT 注意力头内的关系。如前所述,在每一层中,都有几个注意力头,每个头都学习输入数据的不同表示。颜色强度表示注意力权重中的更大权重(较深的颜色表示接近 1 的权重)。

我们可以使用 BERTviz 包来完成此操作:

head_view(attention, tokens, sentence_b_start)

重要提示

该可视化是交互式的。代码在仓库中。尝试使用不同的短语运行它,并探索短语中不同单词之间的不同关系。可视化允许您通过利用下拉模型来探索模型中的不同层。将鼠标悬停在各个单词上,您可以看到各个头的单个权重。

这是相应的可视化:

图 2.17 – 输入中所有单词之间的注意力可视化

图 2.17 – 输入中所有单词之间的注意力可视化

我们还可以同时查看模型的各个头。这使我们能够看到各个头如何建模不同的关系。该模型有 12 个头,对应 12 层,因此模型有 144 个注意力头,因此可以查看超过 100 个相同句子的表示(这解释了模型的能力)。此外,这些表示并不完全独立;早期层学习到的信息可以被后续层使用:

model_view(attention, tokens, sentence_b_start)

重要提示

该可视化是交互式的。代码在仓库中。尝试使用不同的短语运行它,并探索不同短语中不同单词之间的关系。在这里,我们有各种注意力头的集成表示。观察每个头如何具有不同的功能以及它如何对相同输入的不同表示进行建模。

这是相应的可视化:

图 2.18 – 第一层和第二层的模型视图

图 2.18 – 第一层和第二层的模型视图

另一个对当今模型发展至关重要的模型是生成预训练 Transformer 2(GPT-2)。GPT-2 是在大约 40 GB 的文本数据语料库上使用语言模型预训练的因果(单向)Transformer。GPT-2 专门用于预测下一个标记并生成带有输入的文本(它一次生成一个标记;然后将这个标记添加到输入序列中,以自回归过程生成下一个标记)。此外,这可能是第一个使用大量文本进行训练的模型。此外,这个模型仅由解码器组成。GPT-2 是一个模型系列,从 12 层的 GPT-2 小型到 48 层的 GPT-2 XL。每一层由掩码自注意力和前馈神经网络组成。

GPT-2 是生成式模型,作为语言模型进行训练,因此我们可以给它一个输入判断并观察下一个标记的概率。例如,使用“To be or not to”作为输入,概率最高的标记是“be”。

图 2.19 – 当用“To be or not to”输入序列进行查询时,GPT-2 模型与下一个标记相关的概率

图 2.19 – 当用“To be or not to”输入序列进行查询时,GPT-2 模型与下一个标记相关的概率

有时,可能需要了解哪些标记对模型生成下一个标记最为重要。梯度 X 输入是一种最初为卷积网络开发的技巧;在给定的时间步长,我们取每个标记的输出概率,选择概率最高的标记,并计算相对于输入标记的梯度。这给出了每个标记对生成序列中下一个标记的重要性(理由是,输入标记中重要性最高的微小变化会导致输出中最大的变化)。在图中,我们可以看到序列中下一个标记的最重要标记:

图 2.20 – 序列中下一个标记的梯度 X 输入

图 2.20 – 序列中下一个标记的梯度 X 输入

如前所述,除了自注意力机制外,还有前馈神经网络,它在 Transformer 块中扮演着重要的角色(它提供了参数的很大一部分,大约 66%)。因此,一些研究工作集中在检查层中神经元的激活(这项技术最初也是为计算机视觉开发的)。

我们可以跟踪每一层的激活,并且对于每个标记,我们可以监控它们在每一层后的概率排名。正如我们所见,模型从第一层开始就能理解哪个标记最有可能继续序列:

图 2.21 – 每层后五个最有可能的标记的排名热图

图 2.21 – 每层之后最有可能的五个标记的排名热图

由于神经元数量相当多,直接观察它们是复杂的。因此,研究这些激活的一种方法是在首先降低维度。为了避免负激活,更倾向于使用非负矩阵分解(NMF)而不是主成分分析(PCA)。这个过程首先捕捉模型 FFNN 层中神经元的激活,然后分解为一些因素(用户选择的参数)。接下来,当生成一个标记时,我们可以交互式地观察具有最高激活的因素。我们在图中看到的是每个生成标记的因素激发:

图 2.22 – 生成序列时模型的激活的 NMF

图 2.22 – 生成序列时模型的激活的 NMF

我们也可以对单层进行这种分析。这使我们能够分析层中神经元(在模型的图像层 0)的有趣行为。在这种情况下,有一些因素专注于文本的特定部分(开头、中间和结尾)。正如我们之前提到的,由于位置编码,模型跟踪序列中的词序,这在激活中得到了体现。然而,其他神经元是由语法结构(如连词、冠词等)激活的。这表明我们注意到模式中单个神经元跟踪的专门化,这是 transformer 的强大组件之一。通过增加事实的数量,我们可以提高分辨率,更好地理解模式在其激活中编码的语法和语义结构。在模型结构的进一步分析中,我们可以看到层学习不同的表示。

图 2.23 – 生成序列时模型的激活的 NMF

图 2.23 – 生成序列时模型的激活的 NMF

我们已经看到了如何构建 transformer 以及它是如何工作的。现在我们知道了 transformer 的解剖结构,是时候看到它的工作状态了。

应用 transformer

变压器的强大之处在于其能够从大量文本中学习的能力。在这个训练阶段(称为预训练),模型学习关于语言结构的通用规则。这种通用表示可以用于众多应用。在深度学习中,最重要的概念之一是迁移学习,其中我们利用在大量数据上训练的模型的能力来执行与原始训练任务不同的任务。迁移学习的一个特殊情况是微调。微调使我们能够将模型的通用知识适应到特定情况。实现这一目标的一种方法是为模型添加一组参数(在顶部),然后通过梯度下降对这些参数进行特定任务的训练。

变压器已经用大量文本进行训练,并学会了在理解文本中有用的语义规则。我们希望利用这些知识来处理特定应用,如情感分类。而不是从头开始训练模型,我们可以将预训练的变压器适应于对句子进行分类。在这种情况下,我们不想破坏模型的内部表示,而是要保留它。这就是为什么在微调过程中,大多数层都是冻结的(权重没有更新)。相反,我们只训练那些添加到模型顶部的层。想法是保留表示,然后学习如何为我们特定的任务使用它。这两个添加的层精确地学习了如何使用模型的内部表示。为了简单起见,让我们想象我们想要学习如何撰写科学论文。为了做到这一点,我们不需要再次学习如何用英语写作,只需要将我们的知识适应到这个新任务。

在 BERT 中,正如我们提到的,我们在每个序列的开头添加一个特定的标记:一个[CLS]标记。在双向变压器的训练或推理过程中,这个标记等待序列中的所有其他标记(如果你还记得,所有标记都是相互连接的)。这意味着最终向量(最后一层的那个)为序列中的每个元素提供了上下文。然后我们可以利用这个向量来进行分类任务。如果我们有三个类别(例如,正面、中立和负面),我们可以取序列的向量并使用 softmax 进行分类。

<mml:math display="block">mml:miy</mml:mi>mml:mo=</mml:mo>mml:mis</mml:mi>mml:mio</mml:mi>mml:mif</mml:mi>mml:mit</mml:mi>mml:mim</mml:mi>mml:mia</mml:mi>mml:mix</mml:mi><mml:mfenced separators="|">mml:mrowmml:miW</mml:mi>mml:msubmml:mrowmml:mih</mml:mi></mml:mrow>mml:mrowmml:miC</mml:mi>mml:miL</mml:mi>mml:miS</mml:mi></mml:mrow></mml:msub></mml:mrow></mml:mfenced></mml:math>

模型最初并未针对序列分类进行训练,因此我们希望引入一个可学习的矩阵以实现类别分离。这个矩阵代表一个线性变换,也可以通过一个或多个线性层来实现。然后我们应用交叉熵损失函数来优化这些权重。这种设置遵循标准的监督学习范式,其中使用标记数据来适应特定任务。

在这个过程中,我们迄今为止假设 transformer 的其余权重保持冻结。然而,正如在卷积神经网络中观察到的,即使是模型参数的最小微调也能提高性能。此类更新通常使用非常低的学习率进行。

我们可以通过监督微调来将预训练的 transformer 适应新任务。

图 2.24 – 微调 transformer

图 2.24 – 微调 transformer

在第一步中,我们正在移除最后一层(这针对原始任务而言是特定的)。在第二步中,我们添加一个随机初始化的层,并为新任务收集训练示例。在微调过程中,我们向模型展示新的示例(在这种情况下,是正面和负面的评论)。在保持模型冻结(每个示例在正向传播中由整个模型处理)的同时,我们只更新新层的权重(通过反向传播)。现在,模型已经学会了新任务。

使用 Hugging Face 进行微调是一个简单直接的过程。我们可以使用像 distill-BERT(BERT 的蒸馏版本)这样的模型,用几行代码和前一章中使用的数据集。我们需要准备数据集并将其标记化(以便可以使用 transformer)。然后,Hugging Face 通过一个简单的包装器允许我们训练模型。训练的参数存储在TrainingArguments中:

training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=16
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    evaluation_strategy="epoch"
)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset
)
trainer.train()

重要提示

注意到这个过程与训练神经网络非常相似。事实上,transformer 是一个深度学习模型;在训练时,我们使用类似的超参数。

在这种情况下,我们只使用了评论的一小部分。微调的美丽之处在于,我们只需要几个示例就能达到与从头开始训练的模型相似(如果不是更好的)的性能。

图 2.25 – 微调后的混淆矩阵

图 2.25 – 微调后的混淆矩阵

BERT 的训练是在 64 个 TPU(用于张量操作的专用硬件)上进行的,耗时四天;这对大多数用户来说都遥不可及。相比之下,微调可以在单个 GPU 或 CPU 上进行。因此,BERT 在发布时在包括释义检测、问答和情感分析在内的广泛任务上实现了最先进的性能。因此,诞生了几个变体,如RoBERTa和SpanBERT(在这种情况下,我们用一个整个跨度而不是单个标记进行掩码,以获得更好的结果),或者针对特定领域进行了调整,如SciBERT。然而,编码器对于生成任务来说并不理想(因为掩码训练),而解码器则更合适。

要进行机器翻译,原始的 Transformer 模型由编码器和解码器组成。像 GPT-2 这样的模型只有解码器。我们可以像之前看到的那样进行微调,我们只需要以最佳方式构建一个仅由解码器构成的模型的训练数据集。例如,我们可以取一个包含英语和法语句子的数据集,并构建以下微调数据集:<英语句子>后跟一个特殊的<to-fr>标记,然后是<法语句子>。同样的方法也可以用来教模型进行摘要,其中我们插入一个表示摘要的特殊标记。模型通过进行下一个标记预测(语言建模)进行微调。

图 2.26 – 仅解码器模型的微调

图 2.26 – 仅解码器模型的微调

利用模型学习到的知识的另一种方法是使用知识蒸馏。在上一节中,我们使用了 distillGPT-2,它是 GPT-2 的蒸馏版本。蒸馏模型能够从更大的模型中捕获知识,而不会损失显著的性能,但更容易管理。使用大量文本训练的模型会学习到大量的知识。当我们需要针对某些特定任务使用模型时,所有这些知识和技能往往是多余的。我们希望有一个在特定任务上非常强大的模型,但又不想处理数十亿参数的模型。此外,有时我们没有足够的示例让模型从头开始学习任务。在这种情况下,我们可以从更大的模型中提取知识。

图 2.27 – 知识蒸馏的通用师生框架

图 2.27 – 知识蒸馏的通用师生框架 (arxiv.org/pdf/2006.05525)

知识蒸馏可以看作是一种压缩形式,其中我们试图将具有许多参数的已训练“教师”模型中的知识转移到具有较少参数的“学生”模型中。学生模型试图模仿教师模型,并在任务中达到与教师模型相同的性能。在这种框架中,我们有三个组件:模型、知识和算法。算法可以利用教师的 logits 或中间激活。在 logits 的情况下,学生试图模仿教师模型的预测,因此我们试图最小化教师和学生产生的 logits 之间的差异。为此,我们使用一种蒸馏损失,使我们能够训练学生模型。

图 2.28 – 知识蒸馏训练的教师-学生框架(img/B21257_02_28.jpg)

图 2.28 – 知识蒸馏训练的教师-学生框架(arxiv.org/pdf/2006.05525)

对于知识蒸馏,步骤也类似。第一步是数据预处理。对于每个模型,你必须记得选择模型特定的分词器(尽管 GPT-2 的分词器是最广泛使用的,但许多模型有不同的分词器)。然后我们必须在我们的任务上对模型进行微调(没有专门用于分类评论的模型)。这个模型将成为我们的教师。下一步是训练一个学生模型。我们也可以使用一个比教师更小的预训练模型(这使我们能够使用一些示例来训练它)。

一个重要的区别是,我们现在有一个专门用于知识蒸馏的损失。这种蒸馏损失计算教师 logits 和学生 logits 之间的损失。这个函数通常使用 Kullback-Leibler 散度损失来计算两个概率分布之间的差异(Kullback-Leibler 散度实际上是两个概率分布之间差异的度量)。我们可以将其定义为以下:

def distillation_loss(outputs_student, outputs_teacher,
                      temperature=2.0):
    log_prob_student = F.log_softmax(
        outputs_student / temperature, dim=-1)
    prob_teacher = F.softmax(
        outputs_teacher / temperature, dim=-1)
    loss = KLDivLoss(reduction='batchmean')(
        log_prob_student, prob_teacher)
    return loss

到这一点,我们只需要有一种方法来训练我们的系统。在这种情况下,教师将仅在推理中使用,而学生模型将被训练。我们将使用教师的 logits 来计算损失:

def train_epoch(model, dataloader, optimizer, device,
                teacher_model, temperature=2.0):
    model.train()
    total_loss = 0
    for batch in tqdm(dataloader, desc="Training"):
        inputs = {k: v.to(device)
                  for k, v in batch.items()
                  if k in ['input_ids', 'attention_mask']}
        with torch.no_grad():
            outputs_teacher = teacher_model(**inputs).logits
        outputs_student = model(**inputs).logits
        loss = distillation_loss(
            outputs_student, outputs_teacher, temperature)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    return total_loss / len(dataloader)

如以下图所示,学生模型的性能与教师模型相似:

图 2.29 – 教师和学生模型的混淆矩阵

图 2.29 – 教师和学生模型的混淆矩阵

微调和知识蒸馏使我们能够将转换器用于任何监督任务。微调允许我们处理小数据集(在这些数据集中,通常例子太少以至于无法从头开始训练模型)。另一方面,知识蒸馏允许我们在计算成本是限制的情况下,获得一个更小的模型(但性能与一个更大的模型相当)。通过利用这些技术,我们可以处理任何任务。

摘要

在本章中,我们讨论了转换器,这个革命了自然语言处理和人工智能的模型。今天,所有具有商业应用的模型都是转换器的衍生品,正如我们在本章中所学。在机制层面上理解它是如何工作的,以及它的各个部分(自注意力、嵌入、分词等)是如何协同工作的,使我们能够理解现代模型的局限性。我们以直观的方式看到了它是如何内部工作的,从而从多个角度探索了现代人工智能的动机。最后,我们看到了如何使用利用模型先前知识的技巧来调整转换器以满足我们的需求。现在我们可以用几乎任何数据集和任何任务来重新利用这个过程。

学习如何训练一个转换器将使我们理解当我们将这个过程扩展到规模时会发生什么。一个大型语言模型(LLM)是一个具有更多参数并且使用更多文本进行训练的转换器。这导致了使其如此成功的涌现特性,但它的优点和缺点都体现在我们所看到的元素中。

在第三章中,我们将精确地了解如何从一个转换器中获得一个 LLM。在本章中我们所学的知识将使我们看到这一步骤是如何自然而然地发生的。

第三章:探索 LLM 作为强大的 AI 引擎

在上一章中,我们看到了 Transformer 的结构、它的训练方式以及是什么让它如此强大。Transformer 是自然语言处理(NLP)革命的基础,今天的大型语言模型(LLM)都是基于大规模训练的 Transformer。在本章中,我们将看到当我们使用巨型数据集训练巨大的 Transformer(超过 1000 亿参数)时会发生什么。我们将关注如何实现这种大规模训练,如何微调类似的现代模型,如何获得更易于管理的模型,以及如何将它们扩展到多模态数据。同时,我们还将看到这些模型的局限性以及用来尝试克服这些局限性的技术。

在本章中,我们将涵盖以下主题:

  • 发现 LLM 的演变

  • 指令调整、微调和对齐

  • 探索更小、更高效的 LLM

  • 探索多模态模型

  • 理解幻觉以及伦理和法律问题

  • 提示工程

技术要求

大部分代码可以在 CPU 上运行,但最好在 GPU 上运行。代码是用 PyTorch 编写的,大部分使用标准库(PyTorch、Hugging Face Transformers 等)。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr3.

发现 LLM 的演变

LLM 是一个 Transformer(尽管今天开始出现不同的架构)。一般来说,LLM 被定义为具有超过 100 亿参数的模型。尽管这个数字可能看起来是随机的,但随着规模的增加,一些特性开始出现。这些模型旨在理解和生成人类语言,并且随着时间的推移,它们已经获得了生成代码等能力。为了在参数大小之外实现这一点,它们使用大量数据进行训练。今天的 LLM 几乎都是基于下一词预测(自回归 语言模型)进行训练的。

参数增长在 Transformer 领域是由不同方面推动的:

  • 可学习性:根据规模定律,更多的参数应该导致更大的能力和对数据中细微差别和复杂性的更深入理解

  • 表达能力:该模型可以表达更复杂的函数,从而提高泛化能力并降低过拟合风险

  • 记忆:更多的参数允许内部化更多的知识(信息、实体、主题差异)

在接下来的小节中,我们将详细讨论所有这些元素,以解释从 Transformer 到 LLM 的过渡过程中发生了什么。

规模定律

这样大的模型竟然用如此简单的任务语言模型进行训练,这似乎有些令人惊讶。许多实际的自然语言处理任务都可以表示为下一个单词的预测。这种灵活性使我们能够在不同的环境中使用 LLM。例如,情感分析可以被视为下一个单词的预测。句子“The sentiment of the sentence: ‘I like Pizza’ is”可以用作 LLM 的输入,我们可以提取下一个标记为正面或负面的概率。然后,我们可以根据哪个概率更高来分配情感。注意,这个概率是上下文的函数:

P(positive| The sentiment of the sentence: ‘I like Pizza’ is)

P(negative| The sentiment of the sentence: ‘I like Pizza’ is)

同样,我们可以用相同的方法处理其他任务。使用 LLM 进行问答可以被视为在给定问题的情况下生成正确答案的概率。在文本摘要中,我们希望在原始上下文中生成:

问答:P(answer| question)

文本摘要:P(summary|original article)

在下面的图中,我们可以看到使用语言模型几乎可以解决任何任务。例如,在这里,答案是给定前一个序列(问题)的最可能标记:

图 3.1 – 将任何任务重新表述为语言模型

图 3.1 – 将任何任务重新表述为语言模型

我们需要的是一个足够大的数据集,以便模型既能学习知识,又能使用这些知识来完成任务。为此,为训练大型语言模型(LLM)而专门组装了特定数据集。这些数据集通常包含来自各种来源(互联网、书籍、文章、GitHub、不同语言等)的数十亿个单词。例如,GPT-3 使用了 Common Crawl(网络爬虫数据,4100 亿个标记)、Books1 和 Books2(书籍语料库,分别有 120 亿和 550 亿个标记)以及维基百科(30 亿个标记)进行训练。这种多样性提供了特定的知识,同时也提供了任务示例。

与训练数据集的增长(今天,我们谈论的超过万亿个标记)并行,参数数量也在增加。一个变换器中的参数数量取决于三个因素:

  • 嵌入层:向量大小和词汇表(特别是对于多语言模型,这可以非常大)上的参数数量。注意力机制是最重的组件,拥有最多的参数。

  • 自注意力机制:这个组件包括多个权重矩阵,其大小可以随着上下文长度的增加而增长。此外,每个自注意力机制可以有多个头。

  • 深度:变换器由多个变换器块组成,增加这些块的数量会直接向模型添加更多参数。

GPT-3 和其他研究已经表明,大型语言模型(LLM)的性能主要取决于三个因素:模型大小(参数数量)、数据大小(训练数据集的大小)和计算大小(计算量)。因此,从理论上讲,为了提高我们模型的表现,我们应该扩大模型(增加层或注意力头),增加预训练数据集的大小,并增加训练的轮数。这些因素已经被 OpenAI 与所谓的规模定律联系起来。从一个具有参数数量N、数据集D和计算量C的模型,如果两个参数是常数,损失L可以表示为:

LN=(NcN)αNLD=(DcD)αDLC=(CcC)αC

这在以下图表中进行了可视化表示:

图 3.2 – 随着模型大小、数据集大小和计算量的增加,语言模型性能平稳提升(img/B21257_03_02.jpg)

图 3.2 – 随着模型大小、数据集大小和计算量的增加,语言模型性能平稳提升(arxiv.org/pdf/2001.08361)

在这种情况下,损失是交叉熵损失。在后续的研究中,OpenAI 已经表明这种损失可以分解为不可减少损失(因为它与数据熵相关,无法消除)和可减少损失。换句话说,这个规模定律允许我们在训练模型之前计算出期望的性能。我们可以决定是否投资更多来扩大模型或数据集以减少损失(提高性能)。然而,这些常数依赖于架构和其他训练选择:

图 3.3 – LLM 的规模定律

图 3.3 – LLM 的规模定律

虽然这个缩放定律已经被视为理所当然,但现实比这要复杂得多。根据 DeepMind 的 Chinchilla (arxiv.org/abs/2203.15556),性能在很大程度上取决于标记的数量,而不仅仅是 OpenAI 所认为的那样。因此,LLMs 目前可能存在欠拟合,因为它们训练的标记数量少于预期。Meta 的 Llama 也指出,不仅仅是任何标记都适用,它们必须是高质量的。因此,并非所有标记都同等重要,根据其他作者的研究,使用其他模型生成的标记只是蒸馏的一种更复杂的形式。换句话说,为了训练一个模型达到最佳状态,你需要大量的标记,并且它们应该优先由人类产生,而不是合成。不同的研究表明,当使用合成数据进行训练时,模型崩溃的潜在风险。在几个案例中,已经表明,当使用合成数据进行训练时,模型性能会大幅下降(模型崩溃)或者可能会忘记它所学习的一些技能(灾难性遗忘)。

在任何情况下,缩放定律都非常有意义,因为它允许我们在较小的模型上实验不同的架构和变体,然后扩展模型和训练,直到达到期望的性能。拥有超过 1000 亿个参数的模型在训练上成本高昂(从架构、时间和金钱的角度来看),因此最好先实验一个小型的代理模型,然后利用所学知识来训练更大的模型。此外,训练如此大的模型可能会遇到问题(例如训练峰值),能够用准确的缩放定律预测性能是一个活跃的研究领域。

这个缩放定律也只监控损失方面的性能。如前所述,许多任务可以用语言模型(LM)来定义,所以直观上,在 LM 中的更好性能也意味着在下游任务中的更好性能。然而,今天我们试图创建的缩放定律是针对某些期望任务中的性能(如果我们想要一个专门训练为代码助手的模型,我们对其在这些任务中的性能比对整体性能更感兴趣)。

演化特性

模型的涌现特性是我们从 10 亿参数增长到超过 1000 亿参数的主要原因。涌现能力被定义为在小型模型中不存在但在大型模型中出现的特性。第二个特征是它们在某个规模上突然出现。换句话说,模型在某个能力上具有随机的表现,直到达到某个规模时它们才会出现。这些特性不能事先预测,只能在达到某个规模时观察到,这个规模被称为临界规模。在这个临界规模之后,性能随着规模的增加而线性增长。然后,模型在达到某个临界点后,从几乎为零的性能到接近最先进水平,从而显示出不连续的节奏。这个过程也被称为相变。就像一个孩子似乎无法说话,然后超过某个年龄开始发音,然后随着时间的推移技能线性增长一样。

图 3.4 – LLM 中涌现特性的示例

图 3.4 – LLM 中涌现特性的示例

通常,这些技能与复杂的技能相关,如数学推理或多步骤过程。它们只在超过某个规模时出现的事实证明了这种模型的增长,希望超过某个规模后,其他特性也会出现:

图 3.5 – 不同大型语言模型家族中涌现特性的示例(img/B21257_03_5.jpg)

图 3.5 – 不同大型语言模型家族中涌现特性的示例(arxiv.org/pdf/2206.07682)

这些特性并非在相同的模型规模下出现。一些特性会在超过 100 亿(算术计算)之后出现,超过 1000 亿(自我评估、修辞(FoS)检测、逻辑推理等),而其他特性甚至会在超过 5000 亿(因果判断、几何形状等)之后出现。

对于《大型语言模型的涌现能力》的作者(arxiv.org/pdf/2206.07682)来说,推理任务(尤其是涉及多个步骤的任务)对于 LMs 来说是困难的。这些能力会在达到 1000 亿参数后自然出现。同样,超过这个阈值,模型能够理解和遵循指令(指令遵循),而无需给出如何遵循它们的示例。从这个意义上说,更大的模型将能够执行程序(编码能力)。

然而,由于后续研究对这些特性的质疑,对这些涌现特性的兴趣已经减弱。LLMs 确实表现出这些能力,但根据进一步的研究,一旦 LLM 达到一定的性能极限,这些能力就会更加明显。此外,似乎这些任务的成功衡量标准并不好。

上下文长度

大型语言模型(LLMs)以块的形式处理文本,具有特定数量的标记的固定上下文窗口。这个上下文长度的尺寸定义了它们在给定时间内可以处理多少信息。上下文长度越大,模型在给定时间内可以处理的信息就越多。同样,计算成本呈二次增长。因此,上下文长度为 4,096 个标记的模型需要比 512 个标记的模型多进行 64 倍的计算。更长的上下文长度允许捕捉文本中的长距离依赖关系,这与特定任务中的性能相关:

  • 文档摘要:更多的上下文允许进行更一致和简洁的摘要,从而更好地捕捉文档及其关系中的信息。模型捕捉整个文档中的实体及其相关内容。

  • 问答(QA):模型可以找到正确答案背后的复杂关系。此外,在多轮问答中,模型了解之前的答案和问题。

  • 语言翻译:模型更好地保留了上下文,特别是当有长文档需要翻译时(尤其是如果文档中有复杂的细微差别)。更大的上下文长度有助于处理技术文档、术语、多义词和缩写词。

  • 对话式人工智能:模型可以更好地跟踪整个对话。

如以下图中所示,上下文长度越大,模型在一次提示中可以访问的数据就越多。当上下文长度为 512 时,模型只能看到一条评论,而具有更大上下文窗口的模型可以分析数百条:

图 3.6 – 随着上下文长度窗口增加所能适配的评论数量

图 3.6 – 随着上下文长度窗口增加所能适配的评论数量

专家混合

正如我们所看到的,数据量、模型规模和计算预算之间存在复杂的关系。在固定的计算预算下,最好通过减少步骤来训练更大的模型。专家混合(MoE)允许在相同的计算预算下通过扩展模型来训练,从而在更短的时间内获得与密集模型相当的效果。MoEs 通常由两个组件组成:

  • 稀疏 MoE 层:每一层由几个专家组成(通常是八个,但也可以更多),每个专家都是一个神经网络(在最简单的情况下,是一个前馈网络(FFN)层,但它们也可以由多个层组成)。

  • 门控网络或路由器:此组件决定将哪些数据发送给每个专家。在大型语言模型(LLM)的情况下,路由器决定哪些标记被一个或多个专家看到。路由器具有可学习的参数,这些参数在预训练期间与模型的其他部分一起训练。

您可以在图 3.7中看到一个 MoE 层的示例:

图 3.7 – MoE 层的示例:路由器决定将令牌发送给哪个专家;在这种情况下,专家是一个简单的 FFN 层 (https://arxiv.org/pdf/2101.03961)

图 3.7 – MoE 层的示例:路由器决定将令牌发送给哪个专家;在这种情况下,专家是一个简单的 FFN 层 (arxiv.org/pdf/2101.03961)

MoE 背后的想法是,每个专家都专注于训练的不同子集(或者更正式地说,输入空间的不同区域),路由器学习何时调用这种专业知识。这被称为稀疏计算,因为模型不是对所有相同模型的输入都活跃。

这个系统有几个优点:

  • 与密集模型(经典 Transformer)相比,预训练更快。模型在推理时更快,因为不是所有专家都在所有数据上同时使用。

  • 该系统灵活,可以处理复杂分布,每个专家都可以专注于子领域。

  • 它的扩展性更好,因为我们可以在需要时拥有额外的专家。

  • 更好的泛化能力,因为我们可以平均专家的预测(群众的智慧)。

然而,也有一些缺点:

  • 它需要高 VRAM,因为所有专家无论如何都必须加载到内存中。

  • 训练更复杂,可能导致过拟合。此外,如果没有一些调整,模型可能只会使用两个或三个最受欢迎的专家。

  • 微调更复杂,但新的研究正在解决这个问题。MoE 可以有效地蒸馏,我们还可以提取子网络。

  • 更复杂的可解释性,因为我们现在有额外的组件。

这就是为什么今天许多大型模型都是 MoE(例如,GPT-4 或 Gemini)。在下一节中,我们将看到一旦 LLM 进行了预训练,如何适应以更好地与用户互动,或者我们如何微调如此大的模型。

指令调整、微调和对齐

微调如此大的模型可能非常昂贵。在经典微调中,想法是为任务或新领域调整模型的权重。即使是对权重进行几步的轻微更新,对于一个超过 1000 亿参数的模型来说,这也意味着需要大量的硬件基础设施和显著的成本。因此,我们需要一种方法,使我们能够进行高效且低成本的微调,并优先保持模型权重冻结。

内在秩假设表明,我们可以使用低维表示来捕捉神经网络中发生的重大变化。在微调的情况下,微调后的模型权重可以这样定义:

Y=W′Xwith:W′=W+∆W

∆W 代表微调过程中的权重更新。对于内在秩假设,∆W 的所有这些元素并不都是重要的,相反,我们可以将其表示为两个小维度矩阵 A 和 B(低秩矩阵)的乘积。因此,在这种情况下,模型权重保持冻结,但我们只需要训练这两个矩阵:

Y=W′Xwith:W′=W+BA

一个矩阵可以被分解成两个较小的矩阵,当它们相乘时,给出原始矩阵。此外,一个矩阵(尤其是较大的矩阵)包含大量冗余信息。一个矩阵可以被减少为一组线性无关的向量(定义矩阵所需的线性无关向量的数量称为秩)。考虑到这一点,想法是找到两个比原始矩阵秩更小的矩阵,并且它们相乘给出与如果我们进行了微调相同的矩阵更新权重。这个过程被称为低秩****自适应(LoRA)。

LLMs 是过参数化的。虽然这在预训练阶段是有益的,但它使得微调变得非常昂贵。因为 LLM 的权重矩阵有很多线性依赖,存在大量冗余信息,这对于领域自适应特别无用。因此,我们可以以更低的成本学习到更小的矩阵(A和B)。

图 3.8 – 经典微调与 LoRA 对比

图 3.8 – 经典微调与 LoRA 对比

在 LoRA 中,我们保持 LLM 的原始权重冻结。然后我们创建两个矩阵(A和B),当它们相乘时,将具有与模型权重矩阵(W)相同的维度。在微调期间,我们传递冻结模型的输入 X 和变化矩阵(乘积 AB),并得到输出。有了这个输出,我们计算损失,并使用这个损失来更新矩阵 A 和 B(通过经典反向传播)。我们继续这个过程,直到我们对结果满意。

图 3.9 – 获取变化权重矩阵的不同秩矩阵

图 3.9 – 获取变化权重矩阵的不同秩矩阵

在 LoRA 中,我们有一个超参数 r 描述 A 和 B 矩阵的深度。r 值越大,这些矩阵包含的信息量就越大(但也意味着更多的参数和计算成本)。结果显示,即使是低秩矩阵也表现相当好。

LoRA 有几个优点:

  • 它在训练中效率高(对于 GPT-3,一个 1750 亿参数的模型可以通过 LoRA 有效地使用,只需训练 1750 万个参数)。

  • 在推理过程中,它不会增加计算成本(这是一个加法,我们将变化矩阵添加到原始模型权重中)。

  • LoRA 不会改变模型的原始能力。它还减少了微调期间保存检查点相关的内存成本。

  • 我们可以为不同的应用和领域创建不同的变化矩阵。

另一种专注于仅训练添加参数的技术是适配器。在这种情况下,我们在变换器块内添加可调层。这些适配器是具有自动编码器(AE)结构的小层。例如,如果全连接层有 1024 个维度,适配器会投影到 24,然后重新投影到 1024。这意味着我们为每个适配器添加的参数少于 50K。在原始论文中,作者展示了添加适配器可以达到与微调双向编码器表示从变换器(BERT)相同的性能。适配器只需要额外训练 3.6%的参数。相比之下,以传统方式微调如 BERT 这样的模型意味着对所有模型参数进行训练。这意味着对于相同的性能,这种方法在计算上要高效得多。

图 3.10 – 如何将适配器添加到变换器块中(左);结果显示适配器可以以更少的参数达到常规微调的性能(右)

图 3.10 – 如何将适配器添加到变换器块中(左);结果显示适配器可以以更少的参数达到常规微调的性能(右)(arxiv.org/pdf/1902.00751)

适配器的优势在于,你可以通过训练远 fewer 参数(对于 LLM 来说,几百万参数)来进行微调,并且模型保留了原始能力。

然而,许多其他方法试图解决在不训练原始参数的情况下对模型进行微调的问题。例如,一些技术,如提示微调,在模型输入嵌入之前添加一个可训练的张量,该张量学习与新任务相关的细节。前缀微调是另一种技术,我们在所有层的隐藏状态中添加可训练的张量。这些参数在其余参数保持冻结的同时通过梯度下降进行学习。提示微调和前缀微调在训练过程中仍然可能导致不稳定性。LoRA 和适配器仍然是使用最广泛的技术:

图 3.11 – 参数高效的微调方法分类法

图 3.11 – 参数高效的微调方法分类法(arxiv.org/pdf/2303.15647)

虽然技术上可以称之为微调方法,对齐是一种通过额外训练尝试将 LLM 与人类价值观对齐的方法。确实,随着模型能力的增强,人们越来越担心伦理风险(将在后面的章节中详细描述)。对齐的目的是通过减少数学训练与人类期望的软技能之间的不匹配来降低这些风险(即,帮助、诚实和无害):

图 3.12 – 展示对齐前后输出差异的示例( https://arxiv.org/pdf/2308.05374 )

图 3.12 – 展示对齐前后输出差异的示例(arxiv.org/pdf/2308.05374)

在预训练期间,一个大型语言模型(LLM)被训练成仅仅是一个高级的自动补全模型(预测下一个单词)。然而,尽管目标简单,该模型却学会了大量的知识和各种技能。对齐的目的是让模型能够按照人类价值观使用在预训练中获得这些技能。由于人类价值观可能具有主观性,难以用数学目标进行编码,因此人们认为应该使用人类反馈。ChatGPT 的成功背后是基于人类反馈的强化学习(RLHF),它精确地使用强化学习来优化基于人类反馈的 LLM。

RLHF 包括三个主要步骤:

  1. 监督式微调(SFT):我们选择一个提示列表,并要求人类标注员为这些提示编写匹配的输出(从 10,000 到 100,000 对)。我们取一个未对齐的模型(在大文本数据集上预训练的 LLM)并在提示和相应的人类生成输出上进行微调。这就是 SFT LLM,一个试图模仿标注员响应的模型。

  2. 训练奖励模型:我们选择一组提示,并使用 SFT LLM 为每个提示生成多个输出。然后我们请人类标注员根据偏好程度(如有用性或准确性)对它们进行排序。使用这个排序,我们训练一个奖励模型。奖励模型将 LLM 的输出作为输入,并产生一个标量奖励信号,作为衡量该输出与人类偏好对齐程度的一个指标。

  3. RLHF:我们从一个提示中生成 SFT LLM 的输出。我们使用训练好的奖励模型来预测输出上的奖励。使用强化学习算法(近端策略优化(PPO)),我们使用预测的奖励来更新 SFT LLM。添加基于Kullback-Leibler(KL)散度的惩罚项,防止模型偏离其原始分布太远(换句话说,输出文本在 RHLF 后保持一致)。

图 3.13 – 阐述三步过程的示意图( https://arxiv.org/pdf/2203.02155 )

图 3.13 – 说明三个步骤过程的图解(arxiv.org/pdf/2203.02155)

尽管这种方法并非没有问题。收集人类偏好数据相当昂贵,需要雇佣兼职人员作为标注员。这些标注员还必须被选中以避免响应的变异性以及不同质量。其次,这个过程相当复杂且不稳定。直接偏好优化(DPO)是一种替代方案,试图通过消除需要奖励模型的需求来解决这些问题的一部分。简而言之,数据集是根据以下格式创建的:<提示,较差的完成,较好的完成>。DPO 使用损失函数来增加较好完成的概率并降低较差完成的概率。这使我们能够使用反向传播并避免强化学习:

图 3.14 – DPO 在避免强化学习的同时优化人类偏好)(img/B21257_03_14.jpg)

图 3.14 – DPO 在避免强化学习的同时优化人类偏好(arxiv.org/pdf/2305.18290)

指令调整(IT)是一种微调技术,用于提高模型在执行各种任务和通常遵循指令方面的能力。其原理与对齐相似:预训练模型被训练以在大语料库上最小化单词预测,并且不执行指令。大多数与大型语言模型(LLM)的用户交互都是执行特定任务(写文本、创建函数、总结文章等)的请求:

图 3.15 – IT 的一般流程)(img/B21257_03_15.jpg)

图 3.15 – IT 的一般流程(arxiv.org/pdf/2308.10792)

为了解决这种不匹配,IT 行业提出了提高模型能力和可控性的方法。在由指令-输出对(模型的指令和期望输出)构成的集合上进一步训练预训练模型。这个数据集由可以由人类标注或由其他 LLMs(如 GPT-4)生成的指令组成。因此,想法是训练模型以解决具有期望输出的任务。模型使用期望输出进行评估,我们使用这个输出来优化模型。这些指令通常代表 NLP 任务,种类繁多(在某些数据集中多达 61 种不同的任务),包括问答、摘要、分类、翻译、创作写作等任务。这些指令还可以包含额外的内容(例如,在摘要中,我们还提供了要总结的文本)。为了构建这样的数据集,具有更多样化的任务更有益(特别是模型必须进行推理的任务,如果步骤在上下文中存在则更好)。指令调整有几个优点。它使模型能够适应甚至未见过的新任务(确保通用性)并且计算效率高。它还可以用于将模型适应特定领域的特定任务(如医疗、金融等)。此外,它还可以与其他对齐技术(如 RLHF)结合使用。

尽管有这些调整技术,但它已经使 LLMs 领域取得了巨大的进步。这些技术的局限性在于标注者往往存在偏见,而且获取高质量数据集的成本很高。此外,训练具有数十亿参数的模型始终是昂贵的。此外,根据一些作者的观点,使用 AI 编写的指令(或由 AI 生成的测试)作为一种蒸馏方法,但不如使用人类编写的文本有优势。在下一节中,我们将讨论在不处理大型 LLMs 的情况下,如何获得小型 LLMs。

探索更小、更高效的 LLMs

LLMs 展现出令人难以置信的能力,但也伴随着超出训练成本的大规模成本。部署时还需要昂贵的硬件设施,更不用说随着参数数量的增加而增长的简单推理成本。这些大型 LLMs 是通用模型,对于许多任务来说,并不需要拥有拥有 1000 亿参数的模型。特别是对于许多商业案例,我们需要一个能够很好地完成特定任务的模型。因此,在许多情况下,一个小型语言模型(SLM)就足够了。

SLMs 往往在特定领域表现出色,因此可能会失去来自整合各种知识领域的上下文信息。SLMs 可能会失去 LLM 的一些功能,或者表现出较少的推理能力(因此不如灵活)。另一方面,它们消耗的资源远少得多,可以在商业 GPU 或甚至 CPU 上使用(或者在极端情况下,在手机上使用)。

对小型模型更广泛的研究表明,浅层模型(具有较少的 Transformer 块)在语法方面表现优秀,但在一致性方面存在问题。因此,几层就足以保证句法正确性,但为了内容连贯性和创造性,需要更多的层。具有隐藏大小的模型可能在故事的延续上遇到困难,因为这种能力需要将隐藏大小至少增加到 128。更高的嵌入维度会影响生成更准确、相关且听起来更自然的延续的能力(小型嵌入会导致模型生成无意义、矛盾和不相关的输出)。此外,单层模型无法遵循指令(例如,根据输入继续故事);至少需要两层,并且随着层数的增加,容量几乎成比例增加(单层注意力不足以产生足够的全局表示)。

因此,在容量和模型大小之间存在权衡。一般来说,我们可以这样说,获得小型高效 LLM 有三种主要可能性:

  • 从头开始训练小型 LLM:例如,Mistral 7B 或 LLaMA 7B 都是从零开始训练的。

  • 知识蒸馏:一种方法是通过一个更大的模型来训练一个针对特定任务的较小模型(这也可以使用 LLM 和一个小型预训练的 LLM 来完成;例如,使用 GPT-4 和 Bert)

  • 减小模型大小:例如,我们可以使用量化或剪枝等技术来减小 Mistral 7B 等 LLM 的大小。

我们已经在上一章讨论了知识蒸馏,由于 LLM 是 Transformer,因此过程是相同的。float64、float16、int64、int8等。浮点格式用于保存实数,而整型格式只能表示整数。更高的精度意味着一个权重可以表示更大的范围。对于 LLM 来说,这意味着更稳定和更准确的训练,尽管需要更多的硬件、内存和成本。

图 3.16 – 量化过程的示例

图 3.16 – 量化过程的示例

问题在于权重的精度损失可以转化为模型性能的显著下降。不同的量化技术试图通过避免损害原始性能来降低模型的精度。最受欢迎的技术之一是仿射量化映射,它允许使用两个因子从高精度数字转换为低精度数字。考虑范围在[α,β]的x,我们可以得到其量化版本 xq ∈ [αq,βq]:

<mml:math display="block">mml:msubmml:mrowmml:mix</mml:mi></mml:mrow>mml:mrowmml:miq</mml:mi></mml:mrow></mml:msub>mml:mo=</mml:mo>mml:mir</mml:mi>mml:mio</mml:mi>mml:miu</mml:mi>mml:min</mml:mi>mml:mid</mml:mi>mml:mo(</mml:mo>mml:mfracmml:mrowmml:mn1</mml:mn></mml:mrow>mml:mrowmml:mis</mml:mi></mml:mrow></mml:mfrac>mml:mix</mml:mi>mml:mo+</mml:mo>mml:miz</mml:mi>mml:mo)</mml:mo></mml:math>

s=β−αβq−αqz=round(βαq−αβqβ−α)

四舍五入用于提高映射质量。在实践中,我们还需要进行裁剪,因为映射后,获得的价值可能会超出新数据类型的范围。

并非所有模型参数都是有用的,这既是因为存在大量的线性依赖,也因为这些模型实际上存在欠拟合。在神经网络(和大型语言模型)的背景下,移除不必要权重的过程被称为剪枝。这个过程指的是消除权重、连接,甚至整个层。无结构剪枝是一种简单技术,其中,我们从一个预训练模型中消除连接或单个神经元,将参数置零。在最简单的情况下,这意味着我们将低于某个阈值(接近零的权重不包含太多信息)的连接设置为零。无结构剪枝可以创建在推理中性能次优的稀疏模型。另一方面,结构剪枝是一种更复杂的技术,其中我们消除神经元、神经元组、结构组件、整个层或块。结构剪枝旨在通过平衡准确性和压缩来保留原始模型的表现。为此已经开发了算法和其他优化系统。以下图表展示了这两种剪枝方法:

图 3.17 – 剪枝的示意图;白色元素代表被剪枝的元素

图 3.17 – 剪枝的示意图;白色元素代表被剪枝的元素

对于经典神经网络,大多数算法都是基于消除损失与权重之间的曲率,以便我们可以识别哪些权重是最重要的,哪些不是(一种称为最佳脑外科医生(OBS)的方法)。或者,一些方法涉及训练模型,减少连接性,然后重新训练压缩后的模型(这个过程可能需要几个周期)。这些经典方法的问题在于 LLM 由数十亿个参数组成,进行训练和修剪的周期会非常昂贵。因此,有人提出了在修剪后对模型进行微调的可能性,但对于大型 LLM 来说,这仍然在计算上非常昂贵。因此,寻求可以用于 LLM 而不需要重新训练的方法。这不是一项容易的任务,因为过于激进的修剪往往会导致 LLM 崩溃(许多算法在避免崩溃的情况下无法移除超过 10%的权重)。最近,使用修剪掩码的 SparseGPT 等方法在压缩上取得了显著成果(在 1700 亿参数模型上实现了高达 60%的压缩)。

由于模型输出也可以看作是模型层输出的总和加上输入的嵌入,这个总和里会有一些项贡献不大。问题是这些项并不完全独立,因此消除层可能会造成不匹配。不过,你可以通过查看输出来研究每一层的贡献。此外,在每个层中,transformer 学习数据的表示,在一个非常深的模型中,一些层会学习到相似的表示。通常存在一个层次结构,其中深层层比初始层学习到更专业的表示。一些研究从这些假设开始,消除层,特别是具有更相似表示的深层层。结果显示,大型模型比小型模型有更多的冗余层,并且可以在不太多改变性能的情况下进行有效压缩:

图 3.18 – 在 LLM 崩溃之前删除层的百分比 (https://arxiv.org/pdf/2403.17887v1)

图 3.18 – 在 LLM 崩溃之前删除层的百分比 (arxiv.org/pdf/2403.17887v1)

修剪可以减少内存占用和推理时间。它也是一种允许我们研究各种结构组件重要性的技术。此外,它可以与其他技术如量化结合,以进一步压缩。

探索多模态模型

根据定义,LLMs 是用文本训练并用于生成文本的。另一方面,自从 transformer 诞生以来,人们一直在努力将模型扩展到其他模态。添加多模态输入允许模型提高其推理能力,并开发其他能力。人类语音传达了书面文字中不存在的一系列信息:声音、语调、停顿和面部表情增强了沟通,但也可以极大地改变信息的含义。

我们之前看到,文本可以被转换成数值向量。如果我们能将数据类型转换成向量,我们就可以将其输入到 transformer 块中。因此,想法是找到一种方法为每种数据类型获取一个潜在表示。对于图像,在原始 transformer 发布后不久就提出了一种将其适应图像的方法:视觉 Transformer(ViT)。ViT 在多个任务上优于卷积网络。

ViTs 通常仅由编码器构建。在获取图像后,它被分成 16 x 16 的补丁(每个补丁可以被视为文本的一个标记)。这是因为单个像素不包含太多信息,所以更方便的是取一组像素(一个补丁)。一旦分成补丁,这些补丁就会被展平(就像它们是一个补丁序列)。一个澄清:由于图像有多个通道(彩色或 RGB 图像有三个通道),这些也必须考虑。完成这一步后,通常会有一个线性投影步骤来获取所需大小的标记(在此步骤之后,补丁不再在视觉上可识别)。

给定一个高度为 H、宽度为 W 和通道数为 C 的图像,如果补丁大小为 P,我们将得到 N 个标记:

N=HWP2

线性化后的标记长度是 P2 乘以通道数(如果是 RGB 图像则为 3;如果是黑白图像则为 1)。现在,它被投影到一个事先选择的大小(在原始版本中为 768,但也可以不同):

图 3.19 – 将图像转换为标记的过程

图 3.19 – 将图像转换为标记的过程

在这一点上,添加了一个表示类别的特殊标记,并且还添加了一个位置编码器,以便模型知道补丁在图像中的位置。此时,它进入编码器,过程与它们是文本标记时相同。编码器由与之前所见相同的 transformer 块组成:

图 3.20 – ViT 编码过程

图 3.20 – ViT 编码过程

ViTs 可以用于许多不同的任务,例如图像分类、目标检测和分割:

图 3.21 – 使用 ViT 完成的计算机视觉(CV)任务示例

图 3.21 – 使用 ViT 完成的计算机视觉(CV)任务示例

由于音乐序列也是序列,因此它们也可以用变压器进行分析。现在有模型可以处理时间序列、DNA 和音乐序列。考虑到我们为这些模式中的每一个都建立了模型,我们已经开始考虑将它们结合成一个单一模型。

在第一章中,我们看到了如何使用 word2vec 实现嵌入。即使是一个变压器也能产生一个潜在表示,可以被认为是文本的向量嵌入。如果我们移除一个变压器的最后一层,我们可以得到文本的上下文表示(毕竟,变压器的各个层学习的是越来越复杂和上下文化的文本表示)。这种表示可以用于许多应用,我们将在后面详细看到。现在,我们感兴趣的是了解一个 LLM 可以生成代表文本的向量。同时,ViT 可以生成图像的向量表示。每个这些模型都可以为数据类型生成一个单模态嵌入。然而,多模态嵌入可以捕捉图像和文本中存在的所有信息,并将它们联系起来。

由于多模态嵌入会将图像和文本投影到同一个空间,我们可以利用这个嵌入来完成以前不可能的任务。例如,给定一个标题 x,我们可以搜索所有与这个标题相似(或者显然,相反)的图像。其中最著名的是对比语言-图像预训练(CLIP)。CLIP 被设计为一个为图像和文本生成嵌入的模型(今天,也有其他模态的多模态嵌入):

图 3.22 – CLIP 联合训练图像编码器和文本编码器以预测一批(图像,文本)的正确配对(img/B21257_03_22.jpg)

图 3.22 – CLIP 联合训练图像编码器和文本编码器以预测一批(图像,文本)的正确配对(arxiv.org/pdf/2103.00020)

CLIP 使用从互联网收集的 4 亿个(图像,文本)对的数据集进行训练,试图涵盖尽可能多的视觉概念。CLIP 尝试为图像和相应的标题创建表示,使用每个数据类型的编码器(一个变压器模型)。一旦图像和标题被相应的编码器嵌入,这两个嵌入通过余弦相似度进行比较。模型学习最大化图像与其对应标题之间的余弦相似度。同时,它试图最小化与其他不正确配对的相似度(这与我们看到的文本嵌入非常相似,只是这次是多模态的)。之后,我们使用这个预测来更新模型参数(所有两个编码器)。这种学习方法被称为对比学习。

训练被设定为一个分类任务,其中模型预测正确的配对。从这些预测开始,我们将它们与实际预测进行比较,并使用交叉熵损失。一个有趣的发现是,尽管模型用于创建嵌入,但作者使用了预训练模型并将它们组合成一个新的模型。

图 3.23 – 标题与图像之间的相似性矩阵

图 3.23 – 标题与图像之间的相似性矩阵

我们可以使用 CLIP 实现图像和标题的嵌入。一旦我们得到这些嵌入,我们可以使用它们来计算相似度。因此,我们可以获得一个相似性矩阵。使用 Hugging Face 库来做这件事非常简单:

from sentence_transformers import SentenceTransformer, util
model = SentenceTransformer('clip-ViT-B-32')
image_embeddings = model.encode(images, convert_to_tensor=True)
caption_embeddings = model.encode(
    captions, convert_to_tensor=True)
similarity_matrix = util.cos_sim(
    image_embeddings, caption_embeddings)

重要提示

我们正在为图像和标题创建嵌入,然后计算相似性矩阵。

在原始文章中,CLIP 被构思的第一个应用之一是零样本分类。例如,给定一组标签,我们可以要求模型对图像进行分类:

图 3.24 – 零样本图像分类

图 3.24 – 零样本图像分类

CLIP 也可以用于各种其他任务,例如在大数据集上进行搜索或执行图像聚类,然后为这些聚类分配关键词。然而,CLIP 不能用于生成文本,例如为图像生成标题。为此,我们需要一个视觉-语言模型(VLM)。VLM 实质上表现得像 LLM,尽管它也可以回答有关图像的问题,解决了 LLM 的一个限制。换句话说,有了 VLM,我们可以以类似于经典 LLM 的方式进行推理,同时也可以使用图像。一个例子是自举语言-图像预训练(BLIP-2),其中他们没有从头开始创建模型,而是取了一个 LLM 和 ViT,并通过一个桥梁(Q-Former)将它们连接起来。Q-Former 是一个额外的组件,用于将图像编码器与 LLM 连接起来(基本上为我们的 LLM 提供了眼睛):

图 3.25 – BLIP-2 框架概述 (https://arxiv.org/pdf/2301.12597)

图 3.25 – BLIP-2 框架概述 (arxiv.org/pdf/2301.12597)

Q-Former 由两个组件组成(一个与 ViT 交互,一个与 LLM 交互);它是模型中唯一被训练的部分。这个过程分为两个阶段,每个模式一个阶段。在第一阶段,我们使用图像-标题对来训练 Q-Former,使其能够关联图像和文本。在第二阶段,Q-Former 学习到的嵌入被用作软提示,以条件化 LLM 对图像的文本表示(使 LLM 意识到图像)。一旦 Q-Former 被训练,我们就可以使用该模型生成关于图像的文本:

图 3.26 – BLIP-2 对图像的标题

图 3.26 – BLIP-2 对图像的标题

由于它是一个 VLM,我们也可以提出几个问题,并与模型就图像进行聊天:

图 3.27 – 关于图像的 BLIP-2 不同轮次的提问

图 3.27 – 关于图像的 BLIP-2 不同轮次的提问

说到多模态模型,最近一段时间内,另一种模型类型经历了强劲的增长,那就是文本到图像模型。Stable Diffusion 因其图像生成的质量、性能以及向大众的普及而被视为一个里程碑。这个模型的操作可以概括为:给定文本指示(一个提示),系统根据指示生成图像。今天也存在其他替代方案(文本到视频、文本引导的图像修改等),但原理是相似的。从高层次上讲,我们可以说是有三个主要方面:

  • 文本编码器:文本编码器是一个模型(通常是 CLIP 或为该功能专门训练的另一个 LLM),它接受文本并返回文本的向量表示。

  • 图像生成器:这是一个 U-Net,它生成图像表示。在这个过程中,生成受文本条件限制。

  • 图像解码器:将图像表示转换为实际图像。通常,这个组件是一个 ViT 或 AE 解码器。

系统的核心是 U-Net,在这个组件中,扩散过程发生。U-Net 不是直接在图像上工作,而是在一个紧凑的表示上工作,称为潜在表示(这基本上是一个矩阵)。然而,这个潜在表示包含了生成图像所需的信息,这个过程随后在解码器的最后一步进行。

在扩散过程中,从随机噪声开始,我们开始构建一个潜在表示,它获取有关图像的信息。扩散模型基于这样的想法:一个模型,如果给定足够大的训练集,可以学习有关包含模式的信息。在训练过程中,我们取了一个图像,生成一些随机噪声,并向图像添加一定量的噪声。这使我们能够广泛地扩展我们的图像数据集(因为我们可以控制可以添加到图像中的噪声量,从而创建具有更多或更少噪声的不同版本的图像)。然后,模型被训练来识别和预测添加到图像中的噪声(通过经典的反向传播)。然后,模型预测需要减去的噪声,以获得图像(不是图像本身,而是其分布)。通过进行这个去噪过程,我们可以获得一个反向图像(至少,是其潜在表示)。因此,从噪声开始,我们可以得到一个图像,模型被训练在噪声中找到图像。在这个阶段,我们使用解码器并得到一个图像。然而,到目前为止,我们无法用文本来控制这种生成。

图 3.28 – 稳定扩散架构(img/B21257_03_28.jpg)

图 3.28 – 稳定扩散架构(arxiv.org/pdf/2112.10752)

这就是文本编码器发挥作用的地方。LLM 的选择很重要;LLM 越好,这个模型能带来的信息就越好。正如我们之前看到的,CLIP 已经在标题和相应的图像上进行了训练,并且能够产生文本嵌入。CLIP 背后的想法是文本嵌入在嵌入空间中接近相应的图像。到达文本信息作为嵌入后,这些信息将被用来生成图像。实际上,在 U-Net 中,存在交叉注意力,将这种文本信息与生成过程连接起来。

我们已经看到这些模型也可以回答关于图像的问题或生成图像。这些模型并不总是以最佳方式回答问题,这可能会造成严重后果。或者,同时,它们可以生成有问题的图像。我们将在下一节中详细讨论这一点。

理解幻觉以及伦理和法律问题

LLM(大型语言模型)的一个众所周知的问题是它们倾向于产生幻觉。幻觉被定义为产生无意义或不忠实的内容。这被分类为事实性幻觉和忠实性幻觉。事实性幻觉是指模型产生的与真实、可验证的事实相矛盾的回答。忠实性幻觉,另一方面,是与用户提供的指令或上下文相矛盾的内容。模型被训练生成一致的文本,但没有方法来修改其输出或检查其正确性:

图 3.29 – LLM 幻觉示例(img/B21257_03_29.jpg)

图 3.29 – LLM 幻觉示例(arxiv.org/pdf/2311.05232)

模型还可以生成有毒内容,并表现出对特定人口群体的刻板印象和负面态度。防止模型产生伤害非常重要。不同的研究突出了使用 AI(特别是 LLM)可能导致的潜在伤害的不同实例。一个例子是代表性伤害,由一个可以持续传播刻板印象或偏差的模型引起。这以前在情感分类器中看到过,这些分类器将较低的积极情感和负面情绪分配给特定的人群。实际上,LLM 在代表少数群体时可能会产生冒犯性或贬低性的语言,或者它们可能会持续传播关于文化规范、态度和偏见的刻板印象。这可能导致所谓的分配性伤害,当模型不公平地分配资源时。例如,如果 LLM 被用来决定医疗治疗(或工作或信贷)的优先级,它可能会因为从其训练中继承的偏差而分配不公平的访问权限。

事实上,已经有人指出嵌入模型可以放大偏差,这些偏差在嵌入空间中得到了反映。在嵌入空间中识别了有害内容与群体和少数群体的关联。在某些情况下,一些 LLM 使用预训练的嵌入模型权重作为嵌入层的初始化。一些去偏方法(从模型中移除偏差)显示出潜力,但它们仍然远未有效。

这些偏差源于预训练数据集,因此在训练之前进行解毒和移除问题内容非常重要。在微调模型时,检查来自标注者偏差的错误标签也很重要。同时,改变数据源也很重要。实际上,在训练模型时,美国和其他国家产生的文本内容之间存在不均衡。因此,模型继承了其在预训练阶段主导人群的视角。

图 3.30 – 幻觉和虚假信息相关的风险(img/B21257_03_30.jpg)

图 3.30 – 幻觉和虚假信息相关的风险(aclanthology.org/2023.findings-emnlp.97.pdf)

LLM 的另一个潜在风险是它们被用于生成虚假信息。LLM 能够生成可信、令人信服的文本。恶意行为者可能利用它们自动化生成虚假信息、钓鱼邮件、愤怒诱饵和其他有害内容。这就是为什么如何检测由 LLM 生成的文本(或者另加文本生成水印)是一个重要的研究课题。

图 3.31 – LLM 生成虚假信息的分类(img/B21257_03_31.jpg)

图 3.31 – LLM 生成虚假信息的分类(arxiv.org/pdf/2309.13788)

现在,Python 中有几个数据集和库允许人们研究模型偏差。例如,其中一个库是 Hugging Face 的 Evaluate。我们可以使用一组提示并更改提示的性别。之后,我们可以使用 Evaluate 来评估模型如何完成这些提示(使用的模型是 GPT-2)。在这种情况下,Evaluate 使用了另一个为此目的训练的模型:

import evaluate
toxicity = evaluate.load("toxicity")
toxicity.compute(
    predictions=model_continuations,
    aggregation="ratio"
)

如以下热图所示,我们可以看到模型完成提示的方式存在差异:

图 3.32 – 性别化完成和关联毒性的热图

图 3.32 – 性别化完成和关联毒性的热图

模型也可能对职业有偏见。我们可以再次使用相同的库来评估模型完成的提示的极性。在这种情况下,我们评估了与每个完成的提示相关的每个职业的情感:

regard = evaluate.load("regard", "compare")
regard_results = regard.compute(
    data = profession1_completions,
    references = profession2_completions
)

为首席执行官完成的提示比为卡车司机生成的提示更加积极:

图 3.33 – 两种不同职业的偏差分布

图 3.33 – 两种不同职业的偏差分布

另一个有争议的问题是版权问题。这些模型是在受版权保护文本上训练的,并且可以重新生成它们所训练的部分文本。到目前为止,这些大型语言模型(LLMs)的创作者声称他们受合理使用原则的保护,这允许各种公司在未经许可的情况下从互联网上抓取文本来训练模型。然而,今天,一些悬而未决的诉讼可能会改变政治和法律格局。因此,一些公司正在尝试与报纸出版商或社交网络签订许可合同。

与相同问题相关联的是隐私问题风险。这些模型可能会泄露其训练数据的信息。通过对抗攻击,可以从模型中提取信息。模型可以在其参数中存储大量信息,如果使用包含个人信息的数据库进行训练,这些信息以后可能会被提取。因此,正在研究机器反学习方法,使模型忘记个人数据。不同国家正在研究的立法可能要求模型忘记请求的用户信息。我们将在第六章中详细讨论隐私问题。

最后一点是,这些模型现在能够生成代码,这些代码可以用来制作恶意软件和病毒。此外,这些模型将越来越互联,一些研究表明这些大型语言模型(LLMs)可能被用来传播计算机病毒。在下一节中,我们将看到如何通过提示技术有效地使用这些模型。

提示工程

上下文学习(ICL)是大型语言模型(LLMs)最迷人的特性之一。传统上,机器学习(ML)模型被训练来解决基于训练数据的特定任务。例如,在一个经典的分类任务中,我们有输入输出对(X,y),模型学习映射输入 X 和输出 y 之间的关系。任何偏离这个任务的偏差都会导致模型得到低于最优的结果。如果我们为不同主题的文本分类训练一个模型,我们必须进行微调以使其在情感分析中更有效。相比之下,ICL 允许我们不需要对模型进行任何更新就可以在新任务中使用该模型。因此,ICL 是 LLMs 的一个新兴特性,它允许模型在推理时执行新任务,利用获得的知识来映射新的关系。

ICL 首次在文章《Language Models are Few-Shot Learners》(arxiv.org/abs/2005.14165)中定义。作者将 LLMs 定义为少量样本学习者,因为给定提示(LLM 的文本输入)中的一组示例,模型可以映射输入和输出之间的关系,并学习了一个新任务。这种新技能是在上下文中“学习”的,因为 LLM 利用提示中的示例(这随后提供了上下文):

图 3.34 – ICL 能力示例( https://arxiv.org/pdf/2005.14165 )

图 3.34 – ICL 能力示例(arxiv.org/pdf/2005.14165)

在这种情况下,“学习”的概念是不恰当的,因为模型实际上并没有真正学习(实际上,内部参数没有更新),因此学到的技能只是暂时的。换句话说,模型利用它已经学到的(其潜在表示)来执行新任务。模型利用在预训练中学习到的关系,来映射提示中输入和输出之间的潜在函数。

ICL 具有不同的优势:

  • 它反映了人类的认知推理过程,因此它使得描述问题和利用 LLM 变得更容易。

  • 它不需要参数升级,因此速度快,可以与推理中的模型一起使用。它只需要很少的示例。

  • ICL 已经证明,在这个方面,该模型在多个基准测试中可以达到有竞争力的性能。

目前,这种行为的产生方式仍然并不完全清楚。据一些观点,ICL 的根源正是多头自注意力机制以及各种注意力头如何在层之间创建相互连接的电路。一般来说,提示(prompt)提供了几个元素(格式、输入、输出以及输入输出映射),这些元素对于模型成功实现映射至关重要。初步研究表明,模型成功“定位”了它在训练期间获得的潜在概念。换句话说,模型从例子中推断出任务是什么,但提示的其他元素帮助它在参数中定位到完成这种映射所需的潜在概念。具体来说,一些研究指出,演示呈现的格式是最重要的元素(例如,以输入-标签对的形式):

图 3.35 – 提示结构 (https://arxiv.org/pdf/2202.12837)

图 3.35 – 提示结构 (arxiv.org/pdf/2202.12837)

由于 ICL 允许模型通过操作提示在推理中“学习”一个任务,因此这一能力引起了社区的极大兴趣。ICL 使得特定技术得以发展,能够执行越来越复杂的任务,而无需微调模型。

为了清晰起见,我们可以定义一些术语和元素,这些术语和元素是提示(或格式指南)。首先,提示通常包含一个问题或指令:

When was Shakespeare born?

上述示例是一个只包含一个问题的提示,按照惯例,它被称为generate code for function x in Python。能够成功响应此类提示的模型被认为具有零样本能力,而这种能力通过预训练模型的指令调整得到增强:

This movie is awesome – positive
This sandwich is disgusting – negative
This TV series is meh -

这是一个典型的少样本提示案例,我们在提示中提供了示例。更多的演示通常有助于 LLM(3 次、5 次甚至 10 次是常见情况)。提示也可以包含上下文以帮助模型。我们还可以添加期望的响应格式。然而,这些简单的提示存在局限性,特别是对于需要推理的任务。特别是当这需要多个推理步骤时,仅提供示例不足以引导模型走向正确的方向。已经提出了几种技术来避免需要微调。

尤其是在处理算术问题时,看到示例和相关答案对于学习过程并不很有帮助。学生在理解解决问题的逻辑之前,对理解这样的问题更有益。同样,LLM 在获取答案的推理方面比仅有标签的更多示例更有益。思维链提示正是如此;在提示中提供了一个三元组 <input, 思维链, output>。思维链是解决问题的不同中间步骤:

图 3.36 – 思维链示例 (https://arxiv.org/pdf/2201.11903)

图 3.36 – 思维链示例 (arxiv.org/pdf/2201.11903)

添加这些演示使得模型解决任务变得更加容易。然而,它也有缺点,那就是我们必须为几个问题提供高质量的演示,而收集这样的标注数据集是昂贵的。

CoT 的优势在于它将模型的任务分解成一系列更易于管理的步骤。这种行为可以通过在提示中添加“让我们一步步思考”来简单激励。这种看似简单的方法被称为 零样本 CoT 提示。论文《大型语言模型是零样本推理者》(Large Language Models are Zero-Shot Reasoners) (arxiv.org/pdf/2205.11916) 的作者们提出,模型在零样本设置下具有固有的推理技能,因此这种方法是通用的,因为它促使模型使用其在训练中学习的技能:

图 3.37 – 说明使用 LLM 解决问题的各种方法的示意图 (https://arxiv.org/pdf/2305.10601)

图 3.37 – 说明使用 LLM 解决问题的各种方法的示意图 (arxiv.org/pdf/2305.10601)

其他技术,如 自洽性,也被用来提高推理技能。其背后的思想是集成,其中不同的模型可以通过多数投票得出正确答案。在这种情况下,我们生成几个解决方案,然后选择多数解决方案。思维树(ToT)另一方面,利用推理和自我评估能力,其中模型生成不同的推理中间步骤,然后通过利用搜索算法(广度优先搜索和深度优先搜索)来评估它们。通常需要选择候选路径和步骤的数量。这些技术允许模型具有更高的推理能力,但由于模型需要生成多个响应,因此计算成本也更高。

图 3.38 – 使用 DSPy 系统的示例 (https://arxiv.org/abs/2310.03714)

图 3.38 – 使用 DSPy 系统的示例 (arxiv.org/abs/2310.03714)

Python 中的声明式自我改进语言程序(DSPy)是近年来发展起来的一种有趣的新范式。到目前为止,人们一直认为我们必须手动创建这些提示,这需要大量的尝试和错误。相反,DSPy 寻求标准化这个提示过程,并将其转变为一种编程方式。简而言之,DSPy 的作者们(arxiv.org/abs/2310.03714)建议我们可以抽象提示并将其微调为签名,同时将提示技术作为模块使用。结果是,提示工程可以通过优化器实现自动化。给定一个数据集,我们创建一个包含签名和模块(这些技术如何连接)的 DSPy 管道,定义要优化的指标,然后进行优化(我们定义我们寻找的输出和优化器)。这个过程是迭代的;DSPy 引导我们优化提示,然后我们可以使用这些提示。

本节中我们看到的技术是最常用的。还有很多其他技术,但它们通常是这里描述的那些技术的变体。我们现在拥有了成功使用 LLM 的所有要素。

摘要

在本章中,我们讨论了从 Transformer 到 LLM 的过渡。Transformer 是 20 年来 NLP 研究的优雅演变和综合,结合了当时研究中的最佳成果。本身,Transformer 包含了一系列使它成功和通用的元素。模型的核心是自注意力,这是一个关键工具——但也是 LLM 的主要限制。一方面,它允许学习复杂的文本表示,使 LLM 能够执行无数任务;另一方面,它具有巨大的计算成本(尤其是在扩展模型时)。LLM 不仅能够解决分类等任务,还能通过使用文本指令执行需要某些推理的任务。此外,我们还看到了如何将 Transformer 与多模态数据相结合。

到目前为止,该模型只能生成文本,尽管它也能生成代码。在这个阶段,为什么不允许模型执行代码呢?为什么不允许它使用可以扩展其能力的工具呢?这就是我们将在下一章中看到的内容。

进一步阅读

第二部分:AI 代理和知识检索

本部分重点关注通过使 LLMs 能够访问、检索和推理外部知识源来扩展其功能。它从创建能够与网络交互、检索实时信息并执行超出简单问答任务的 AI 代理开始。接下来的章节探讨了检索增强生成(RAG),从基本的管道开始,逐步发展到更模块化和可扩展的系统,以减少幻觉并提高事实准确性。然后介绍了通过知识图谱(GraphRAG)使用结构化知识作为表示和推理信息的有力方法。最后,本部分讨论了如何通过与动态环境的交互使用强化学习来对齐代理行为并改善决策。这些章节共同展示了如何构建不仅具有语言能力,而且具有情境感知、目标驱动并基于外部信息的代理。

本部分包含以下章节:

  • 第四章**,使用 LLM 构建网络爬虫代理

  • 第五章**,通过 RAG 扩展您的代理以防止幻觉

  • 第六章**,高级 RAG 技术在信息检索和增强中的应用

  • 第七章**,创建和连接知识图谱到 AI 代理

  • 第八章**,强化学习和人工智能代理

第四章:使用 LLM 构建网络爬虫代理

法国哲学家丹尼斯·狄德罗曾说,“如果他们找到一只能够回答所有问题的鹦鹉,我会毫不犹豫地宣称它是一个智能生物。”狄德罗指的是鹦鹉,但一个大型语言模型(LLM)可以被定义为一种复杂的鹦鹉。回答问题和理解问题之间存在着区别。因此,今天,我们并不将 LLM 定义为智能生物。尽管如此,LLM 可以非常出色地回答几乎任何问题。尽管具有这样的回答能力,LLM 却无法执行动作。因此,人们尝试通过使用代理来解决这一主要限制。

人工智能代理是 LLM 的扩展,使其从语言模型向具有自主性、反应性、主动性和社交能力等能力的系统转变。这项研究一方面关注特定应用(如掌握国际象棋或围棋等游戏),另一方面关注更一般的能力,如记忆、长期规划、泛化和与用户的有效互动。这些都被认为是通向人工通用智能(AGI)方向的第一步。根据作者和哲学家尼克·博斯特罗姆的说法,“机器智能是人类将永远需要的最后一种发明” (x.com/TEDTalks/status/1191035758704037891)).

通用人工智能(AGI)实际上是一种在一系列认知任务(推理、规划和学习——因此,代表知识)中达到或超过人类智能的智能类型。创建 AGI 是几家主要公司(如 OpenAI 和 Meta AI)的目标。AGI 可能成为人类在复杂任务(如研究)中的助手(根据某些观点,甚至可以取代人类)。尽管许多公司对此持积极态度,但一些有影响力的研究人员,如杰弗里·辛顿,对此发展表示担忧。杰弗里·辛顿教授说,“有 10%的可能性这项技术会引发对人类造成灾难性后果的结果。”在本章和接下来的章节中,我们将重点关注那些专注于提高模型能力的模型和方法。

我们将要探讨的第一步是如何让 LLM 摆脱其“盒子”。例如,我们将看到如何使模型能够从互联网上检索信息。

在本章中,我们将涵盖以下主题:

  • 理解大脑、感知和动作范式

  • 对人工智能代理进行分类

  • 理解单代理和多代理系统的能力

  • 探索主要库

  • 单个代理的一般能力

  • 创建一个用于搜索网络的代理

技术要求

大多数这段代码可以在 CPU 上运行,但最好在 GPU 上运行。代码是用 PyTorch 编写的,大部分使用标准库(PyTorch、Hugging Face Transformers、LangChain、pandas 和 Matplotlib)。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr4。

理解大脑、感知和动作范式

代理可以被定义为具有行动能力的实体。在哲学上,代理是一种也拥有欲望、信念和意图的存在。传统上,“代理”和有意识实体之间存在重叠。有意识实体还应拥有自己的内部状态,使其能够根据其内部表征来理解世界。

AI 代理的定义在于其执行动作的能力,但它不具备欲望和意图(不幸的是,正如我们在上一章讨论的那样,模型继承了其训练集的偏见,因此我们可以模糊地谈论信念)。LLM 拥有内部状态,但这仅仅是它从训练数据中学习到的表征。所以,不,AI 代理不是有意识的实体。尽管术语“代理”(以及其他如“表征”和“内部状态”)在哲学上有不同的含义,称 LLM 为有意识的是一种拟人化的谬误。

同时,通过语言建模,LLM 学习到文本的有用表征以及如何将现有元素置于上下文中。然后,LLM 可以通过上下文学习将提示的指令与它所学习的内容联系起来,从而解决问题。在指令调整期间,模型学习执行任务,所有这些任务都是使模型能够执行动作的技能。我们可以将任务定义为具有明确目标的动作集合,而动作则是一个可完成的单个行为。

因此,一个 AI 代理可以被定义为一种通过一组传感器感知其周围环境、做出决策并实施该决策的人工实体。这个定义相当宽泛,并被用来定义各种系统。在这本书中,我们将专注于基于 LLM 的代理。作为一个进一步的定义,我们将使用一个由三个部分组成的框架:

  • 大脑:系统的主要组件,它整合信息、存储信息并做出决策

  • 感知:扩展模型在感知领域能力的组件,允许系统从不同的模态(文本、听觉和视觉模态)获取信息

  • 动作:使模型能够行动并使用工具来修改其环境(或对环境中的变化做出反应)的组件

我们可以在以下图中看到这些组件是如何相互关联的:

图 4.1 – 基于 LLM 的代理的概念框架,包含三个组件:大脑、感知和行动 (https://arxiv.org/pdf/2309.07864)

图 4.1 – 基于 LLM 的代理的概念框架,包含三个组件:大脑、感知和行动 (arxiv.org/pdf/2309.07864)

因此,LLM 可以被视为代理系统的“大脑”,其中 LLM 可以访问使其能够执行动作或感知的工具。这个系统允许扩展 LLM 的感知和行动空间,从而增强其自身的能力(多模态扩展允许它整合不同类型的信息,互联网的接入允许它获取实时信息,电子商务工具允许它进行交易)。实际上,正如我们在上一章中看到的,LLM 可以表现出推理能力,这些能力可以通过如思维链(CoT)或其他提示方法来增强。此外,通过上下文学习,该模型可以将其能力推广到新的任务中。CoT 提示可以整合来自环境的反馈,从而创建反应性系统。

我们在代理中寻找四个基本属性:

  • 自主性:代理应能够在没有人类干预的情况下运行。此外,代理不应需要明确的指令来完成一项任务,而应能够在不进行逐步描述的情况下执行它。LLM 已经显示出一些创造力和解决任务的能力,而无需解释所有步骤。

  • 反应性:代理应能快速对环境中的变化做出反应,感知外部状态的变化,并做出适当的反应。对于 LLM 来说,这已经在文本层面上发生了(例如,在对话中,话题可能会改变)。扩展 LLM 的多模态功能允许整合不同类型的信息和刺激。

  • 主动性:代理的反应不应仅仅是响应,而应指向一个目标。换句话说,代理应能够根据环境中的变化进行推理和制定计划(这些能力可以通过如 CoT 等推理导向的提示技术来激发)。

  • 社交能力:代理应能够与人类或其他代理进行交互。这是表现出对话和理解技能的 LLM 的优势之一。实际上,可以创建具有不同目标和任务的基于不同 LLM 的代理的环境。具有多个代理的环境可以促进团队合作行为(其中代理进行协调)。

图 4.2 – 具有多个代理的模拟环境的截图

图 4.2 – 具有多个代理的模拟环境的截图

在图 4.2中,我们可以看到代理不仅与环境互动,还彼此互动。通过协作,代理可以解决复杂任务。这展示了基于 LLM 的代理可以获得的复杂能力。

协作行为的例子之一包括 25 个代理在一个为论文《生成代理:人类行为交互模拟》创建的类似《模拟人生》的环境中,该论文由 J. S. Park 等人撰写(arxiv.org/pdf/2304.03442)。用户可以观察并干预代理规划他们的日子、分享新闻、建立关系以及协调团队活动。

在接下来的章节中,我们将分析 AI 代理(基于 LLM)的各个组成部分,从所谓的“大脑”开始。

大脑

大脑是系统的核心,负责几个功能:保存信息、寻找知识、推理和决策。由于这个系统的核心是一个 LLM,所有交互都是基于自然语言的。这是一个优势,因为这些交互和操作可以被人类理解,因此可以监控(尤其是在出现问题时)。由于代理可以与其他实体互动,并且周围环境发生变化,它必须能够进行多轮交互对话(同时与多个实体进行对话,涉及不同主题、复杂结构和基于先前历史的理解)。如果代理的对话技巧不佳,当与人类互动时,人们会感到沮丧,因此模型能够清晰沟通非常重要。模型必须能够理解指令、理解传入的信息、整合这些信息,并适当地对任务做出响应。

今天的 LLM 能够以高质量进行这种类型的对话。由于对齐,对话技巧在近年来呈指数增长。指令调整使得 LLM 能够响应指令并执行任务。

另一个重要组成部分是模型知识,它被分为以下几类:

  • 语言知识:对一种语言的语义和语法的了解。这使得 LLM 能够以正式的方式与人类互动,并且如今有不同语言的 LLM 以满足需求。

  • 常识知识:大多数个体都知道的一套规则和事实。例如,任何人都可以见证重力的效果或理解人类不能飞行。这类信息在提示或上下文中没有具体提及,但对于模型高效地完成任务或回答问题(以及避免误解)是必要的。

  • 领域知识:特定于某个专业领域(例如,科学或医学)或技术领域(例如,数学或编程)的知识。这是在某个领域取得成功所必需的知识或技能。现在有各种领域的专业 LLM(医学、金融等),或者从通用模型开始,你可以获得一个专业模型(微调)。

此外,重要的是要记住,模型的知识在预训练时是冻结的。一个 LLM 无法获取信息(持续学习)或记住与用户的过去交互。正如我们将在下一章中看到的,有一些方法可以克服这一限制。

仅拥有信息对于大脑来说是不够的;我们的代理必须能够进行推理和规划。具有 CoT 和自洽性(我们在上一章中看到的)的技术可以帮助模型更好地推理任务解决方案。一般来说,逐步推理有助于模型拥有任务解决和规划所需的步骤。对于代理来说,规划是一个关键组成部分,因为为了解决任务,模型必须选择最合适的步骤来实现目标。一般来说,这是一个两阶段的过程:

  1. 计划制定:模型将任务分解为子任务。根据方法的不同,LLM 将任务分解为不同的步骤,然后依次执行它们。其他研究表明,自适应策略更好,其中一次执行一个步骤(这可以随后进行评估)。

  2. 计划反思:在制定计划后,建议分析和进行计划反馈分析。一旦描述了计划,LLM 可以评估它,或者可以有一个第二模型来评估第一个模型的工作。

假设我们拥有多个大型语言模型(LLM)。我们的选择可能会受到空间或内存限制的影响。此外,我们可能在推理过程中遇到速度问题(如果模型响应时间过长,用户体验将受到影响)。然后我们可以通过评估速度(每秒生成的标记数)和相对性能(每秒每十亿参数的性能)来进行基准测试。

图 4.3 – 对不同 LLM 生成速度进行基准测试的两个图表:A)显示了每秒生成的标记数,B)显示了每秒每十亿参数生成的标记数

图 4.3 – 对不同 LLM 生成速度进行基准测试的两个图表:A)显示了每秒生成的标记数,B)显示了每秒每十亿参数生成的标记数

A) 在图 4.3 中显示了响应指令“简要描述人工智能代理是什么”时每秒生成的标记数。B) 显示了每秒每十亿参数生成的标记数(数值越高意味着模型效率越高)。

此外,始终评估响应质量是个好主意。一种简单的方法是让一个模型如 GPT-4(或任何比初始模型更大的模型)评估响应。

图 4.4 – 模型答案评估

图 4.4 – 模型答案评估

如*图 4**.4 所示,GPT-4 评估了不同模型生成的答案。每一列代表 GPT-4 分配的分数(整体质量、完整性和真实性)。

总结一下,以下是一些关于选择哪个 LLM 作为 AI 代理系统大脑的建议:

  • 首先的选择是是否通过 API 使用闭源模型(例如 GPT-4 或 Claude)或开源模型(例如 Mistral 或 Meta 的 Llama)。在前一种情况下,重要的是评估专有模型的成本(每次推理成本、集成到应用程序中的成本)。在后一种情况下,应通过平衡计算成本和性能来选择参数数量。

  • 考虑模型的基础设施成本。一个 LLM 和其他系统组件必须托管在基础设施中。例如,我们的 LLM 可能托管在 Azure 上,参数数量越多,成本就越高。

  • 几乎所有模型都对语言学和常识都有很好的了解。另一方面,对于某些特定领域,你可能需要一个具有知识领域的模型。已经有了一些被调整并开源的模型(例如,用于金融的 FinGPT),或者如果你拥有数据,你可以决定自行进行微调。或者,可以采用检索方法,我们将在后面的章节中看到。

在下一节中,我们将讨论如何将这个大脑连接到外部世界。

感知

虽然 LLM 可能是大脑,但它们只能理解文本输入,因此缺乏视觉感知(例如,尽管 ChatGPT-4o 现在不仅可以接受文本输入,还可以接受图像输入并描述图像中的内容,但这种功能并非 LLM 本身的技术组成部分)。作为人类,我们极其依赖我们的视觉感知。视觉使我们能够获取关于外部世界以及环境中物体之间关系的巨大信息量。同样,还有其他模态使我们能够获取我们希望代理能够感知的环境实时信息。例如,连接到家用电器的代理如果传感器检测到雨,可以关闭窗户;如果摄像头检测到强烈的阳光,可以降低百叶窗。

作为有感知的生物,我们整合从感官器官接收到的信息,对外部刺激做出反应。为了使代理能够对环境的变化做出反应,它必须能够感知变化。

为了帮助语言模型理解视觉输入,最简单的解决方案是使用另一个模型进行图像字幕。然后,这些字幕可以作为任务指令的额外上下文插入到提示中。这种方法的优势在于它易于解释,并且可以使用预训练模板进行字幕。然而,在字幕过程中,信息会有所损失,结果并不代表视觉信息的复杂性。而不是使用字幕,PaLM-E (arxiv.org/pdf/2303.03378)) 和其他工作使用具身****语言模型。

PaLM-E 是一个用于具身推理任务的单一通用多模态语言模型。该模型直接集成到嵌入图像和文本中,允许解决视觉和语言任务。

感官模态输入(如图像)直接纳入语言模型的输入。其理念是图像被嵌入到与语言标记相同的潜在嵌入中。随后嵌入的向量随后被传递到变换器块,就像它们是文本输入一样。然后,模型被微调并学习如何关联各种模态中存在的信息。

或者,正如我们在上一章中通过 BLIP-2 所看到的,我们可以通过结合两个已经训练好的模型并保持它们冻结来实现多模态。相反,我们训练查询变换器(Q-Former)模块,以使视觉编码器和语言模型进行通信。这种方法的优势在于我们只需要对一个参数数量少得多的模块进行训练。此外,语言模型没有视觉-语言对齐,这可能导致灾难性的遗忘。

视频输入可以被视为具有额外时间维度的视觉输入。视频由一系列连续的图像帧组成(然而,帧之间存在关系,这些信息必须被保留)。为了防止一瞬间的模型看到未来并理解时间顺序,模型如 Flamingo (arxiv.org/pdf/2204.14198) 使用了掩码机制。

听觉输入也传递着重要的信息。例如,在人类语言中,信息不仅限于消息的内容(如语调、停顿等),还有一些与特定危险或物理事件相关的声音。一些模型在处理与听觉信号相关的特定任务上表现出色。例如,Whisper 模型可以用于语音转文本,之后可以将转录内容用于语言模型。此外,音频频谱图是信息丰富的来源,可以表示为图像(随时间变化的频率谱)。许多模型是基本的视觉变换器,已经被调整为处理频谱图。

实际上,LLM 可以调用其他模型来执行其他听觉任务(如文本到音频、语音翻译和识别、语音分离、声音提取等)。如第三章所述,多模态是指 LLM 可以接受除了文本之外的其他模态作为输入(如图像、视频、音频等)。AudioGPT (arxiv.org/pdf/2304.12995) 是这种方法的例子,其中我们有一个 LLM 与音频基础模型(每个模型都专注于不同的任务)进行交互。

图 4.5 – AudioGPT 的高级概述 (https://arxiv.org/pdf/2304.12995)

图 4.5 – AudioGPT 的高级概述 (arxiv.org/pdf/2304.12995)

当然,现实世界中还有其他类型的传感器输入。例如,嗅觉或触觉等模态更复杂,需要传感器。然而,在各个行业中,存在接收来自机器输入的传感器(如温度、湿度等)。一个大型语言模型(LLM)可以直接或通过中间模型整合这些信息。此外,模型还可以从其他来源接收信息,例如激光雷达(LiDAR)、全球定位系统(GPS)以及互联网。

行动

在生物体中,我们具有对信号的感知及其解释,然后是相应的反应。例如,动物可以视觉上感知捕食者的形象(感受其动作和气味),其大脑将整合这些信息并决定最佳行动方案(隐藏或逃跑)。对于我们的智能体,我们可以期待类似的情况,其中感知到的信号被整合,LLM 计划任务,然后由专门的行动模块执行。输出的最简单例子是文本:LLM 具有固有的生成能力,可以响应指令生成文本。LLM 的能力可以通过工具来扩展。实际上,我们人类可以通过使用工具来解决复杂任务,这些工具可以扩展我们身体的固有能力(或使任务执行更快或更有效率)。

显然,模型需要理解可用的工具以及如何使用它们。LLM 本身可以泛化到一定限度(零样本能力),但有一些技术可以提高其使用这些工具的能力(例如,少样本模型)。我们将在后面看到的一些方法将类似于为模型提供使用手册。学习如何使用这些工具也可以作为反馈进行,这样 LLM 就可以进行相应的调整。

定义动作的一个更复杂方面是称为具身动作的子分支。到目前为止,交互一直是在虚拟环境中进行的。在具身中,我们将系统扩展到外部世界。根据具身假设,人类通过与环境持续互动和反馈来发展他们的智慧,而不仅仅是通过阅读关于它的教科书。因此,如果我们想要实现通用人工智能(AGI),模型应该能够与环境交互。AGI 可以使我们实现以前只能想象的应用,因为它可以实时监控外部环境并采取复杂和复杂的目标行动(例如,采取行动对抗全球变暖、监控核聚变,或发送探测器自主探索太空)。然后,一个 LLM 可以嵌入到机器人中,从而获得一个身体,能够探索环境并从中学习。

在下一节中,我们将更深入地探讨代理的学习方式以及如何更好地对它们进行分类。这将帮助我们更好地定义和规划在需要时的人工智能代理。

人工智能代理分类

在本节中,我们将讨论如何最好地分类代理,并更详细地讨论这样一个复杂系统是如何学习的。第一种分类是在仅存在于虚拟环境中的代理和具身代理之间。

数字代理被限制在虚拟环境中。再次强调,我们与虚拟宇宙的交互程度各不相同。最简单的代理与单个用户进行交互。例如,代理可以在虚拟环境中编程为 Jupyter 笔记本,尽管它可以搜索互联网,但它的交互相对较小,因此主要是被动的。有两个后续的扩展级别:

  • 动作代理在模拟或虚拟世界中执行动作。游戏代理与其他代理或用户进行交互。这些代理通常有一个目标(例如赢得游戏)并且必须与其他玩家互动以成功实现其目标。通常使用强化学习算法通过向模型提供奖励来训练系统,当它实现某些目标时。

  • 交互式代理是动作代理的扩展。该模型与世界进行通信并可以修改它(这些不一定是物理动作)。

一旦我们决定了我们系统交互的限制,重要的是决定它应该如何处理任务。因此,问题是:模型是如何决定如何规划动作的?

这是系统的一项基本技能:如何将任务分解为动作以及优先考虑什么。我们将从高层次讨论可能的系统,特别是针对任务规划。

图 4.6 – 现有 LLM-agent 规划工作的分类 (https://arxiv.org/pdf/2402.02716)

图 4.6 – 现有 LLM-agent 规划工作的分类 (arxiv.org/pdf/2402.02716)

在现实世界中,任务通常是复杂的,几乎不可能一步解决它们。因此,代理必须将任务分解成一系列更易于管理的子任务(子任务也可以由一系列要解决的步骤组成)。在这个过程中,它首先必须决定如何将任务分解成各种子任务,然后如何解决它们。通常有两种解决这一挑战的方法:

  • 分解优先方法 (图 4.7a): LLM 将任务分解成一系列子目标,并在解决前一个目标后为每个目标创建一个计划来顺序解决它们。这个系统受到零样本 CoT 的启发,LLM 被要求通过两个明确的提示进行两个步骤的过程:“让我们首先制定一个计划”和“让我们执行这个计划”。这种方法的优势是给模型提供了一个任务概述,减少了幻觉和遗忘。另一方面,由于一切都在一开始就计划好了,模型无法纠正可能发生在某些步骤中的错误。

  • 交错分解方法 (图 4.7b): 任务分解和规划是交错进行的。换句话说,我们生成一个子任务,并使用一个计划来解决它,直到我们解决了整个任务。交替推理和规划允许模型通过逐步处理整个过程来提高其规划能力。这种方法可以动态调整任务解决方案。它的缺点是,如果问题过于复杂,它可能会在没有得到结果的情况下创建昂贵且漫长的推理-规划链。

图 4.7 – 任务分解方法的类型 (https://arxiv.org/pdf/2402.02716)

图 4.7 – 任务分解方法的类型 (arxiv.org/pdf/2402.02716)

对于这两种方法,存在变体和替代方案。例如,受自洽提示(其中我们对单个问题采样不同的推理路径)的启发,在多计划选择方法中,为每个任务生成几个不同的计划。这是因为即使模型可以进行推理,它也可能生成一个不正确或不可行的计划。模型为单个任务生成几个候选计划,然后我们可以利用不同的算法来选择最佳行动计划。在最简单的版本中,我们选择多数投票策略,但也有一些利用树搜索算法或强化学习的替代方案。这种方法通常在解决复杂案例时成功,并且使用启发式算法降低了在扩展假设空间中解决问题的成本。另一方面,生成不同的路径具有更高的计算成本(以及更高的时间成本风险),并且由于它使用随机过程,可能不一致。

另一种方法是外部规划辅助规划,其中集成了外部规划器。例如,可以添加符号规划器来识别解决方案的最佳路径。今天,也有神经规划器(更轻的神经网络)来帮助 LLM 找到最佳计划。换句话说,LLM 进行的是可以被视为缓慢、沉思的过程的推理,而规划器提供的是快速、本能的反应。这种慢速和快速思考也可以交替进行,首先制定一个快速计划,然后使用 LLM 来解决任何错误。这种方法资源效率高,对于需要代码生成的任务似乎很有希望。然而,系统的开发和实施是复杂的。

为了避免幻觉和其他错误,另一种可能的方法是反思和精炼。这可以被视为一种交错分解扩展,其中 LLM 进行生成、反馈和精炼的迭代过程。在每次生成步骤之后,模型还会对计划生成反馈,然后使用这些反馈来进行精炼。在更复杂的版本中,还有一个额外的模型来评估计划(评估器)并提出反馈。还可以将环境变化纳入反馈中,使系统特别灵活。尽管有潜力,但无法保证精炼过程将使模型解决目标。LLM 可能会陷入连续的链条中,尤其是在过程复杂时。

记忆增强规划是一种试图克服模型当前上下文长度限制的方法。对于智能体的记忆增强规划是指使用外部记忆系统来增强智能体的决策和规划能力。这种方法允许智能体存储、回忆和利用过去的经验、观察或计算,以改善复杂任务中的性能。想象一下,一个被分配清洁房子的机器人吸尘器。没有记忆,它会随机在房子里移动,可能会反复清洁相同区域或错过一些地方。有了记忆增强,机器人会保存一个地图(记忆),记录它已经清洁的地方和障碍物(如家具)的位置。这使得系统可以规划下一步行动,不重复清洁区域,从而高效地覆盖整个房子。

实际上,一个任务可以被分解成几个子任务,这些子任务又可以进一步分解。与规划和中间结果一起,可以生成比上下文所能容纳更多的信息。

检索增强生成(RAG)是一种技术,它允许检索信息以供后续生成使用(我们将在下一章详细讨论这一点),并且可以用来存储智能体的过去经验。在 RAG 中,存在一种外部记忆,形式为数据库,在每次用户查询时,我们可以搜索回答问题或执行动作所需的环境(这个环境成为模型输入的一部分)。换句话说,模型可以找到以前的任务规划、其他任务解决方案或可以服务于任务解决方案的附加信息。或者,也可以使用这些以前的经验来微调模型。在以前的任务上的微调有助于后续任务的泛化。一方面,使用 RAG 的成本较低,但要求检索准确,并且找到的过去经验与任务相关。微调的成本较高,但允许模型存储经验(一种内部化的形式)。甚至还有更复杂的 RAG 版本,其中构建结构来模拟人类的短期和长期记忆(前者用于存储环境中的临时变化,后者用于巩固重要信息)。

正如我们将在下一节中看到的,我们可以在单个系统中拥有单个智能体或多个智能体进行交互。这种灵活性使我们能够通过选择适当的架构(一个或多个智能体)来处理复杂任务。在第九章和第十章中,我们将回到这个主题,并探讨实际中的多智能体系统。

理解单智能体和多智能体系统的能力

讨论智能体的能力以及如何使用它们来完成任务是重要的。从概念上讲,我们的智能体可以行动的场景必须被定义。面向任务部署是最简单的场景,其中智能体在某个任务中协助人类。这类智能体需要能够解决基于任务的问题或将其分解为可管理的子任务。这个智能体的目的是理解用户的指令,然后理解任务,将其分解为步骤,制定计划,并执行该计划,直到目标实现。单个智能体可以在网络或现实生活场景中执行这些任务。

在网络场景中,一个智能体必须能够执行网络上的操作(因此需要连接到互联网)。大型语言模型(LLM)有潜力自动化各种任务,例如在线购物、发送电子邮件和填写表格。专注于这些任务的智能体必须能够适应各种网站的变化。LLM 智能体在这个领域受到青睐,因为网站通常包含大量的文本内容。即使信息量很大,智能体仍然可能遇到问题(性能下降)。事实上,如果相关信息散布在过多的无关背景中,模型可能会产生幻觉,无法完成任务,或者无法进行规划。为了提高模型的能力,一个常用的工具可以读取 HTML。

在实际场景中,一个智能体必须能够执行操作并具备常识推理能力(例如,在互联网上购物的智能体)。对于一个仅用大量文本训练过的 LLM 来说,这些任务可能特别复杂。例如,尽管它可能训练过关于日夜交替的文本,但没有进一步的指令,模型很难理解如何在光线变化时定位自己。此外,智能体在规划行动时必须具备常识(这些行动必须是可行的,并且不违背常识)。因此,智能体在未来的实体机器人部署中需要空间信息来理解其环境。

以创新为导向的部署是一个更复杂的场景(并且代表了未来几年来的发展趋势,而不是当前的应用),智能体不仅必须执行任务。这些智能体必须在科学领域展现出一些探索能力(例如,实验室助手、应用规划或软件设计)。复杂和创新的项目很难仅通过文本信息来定义;它们是多维的。智能体需要清楚地理解整个知识领域,并能够从中进行外推。这类智能体可以用来开发代码和软件,或创造新材料,进行实验等等。尽管这是一个活跃的研究领域,LLM 也显示出一些这些所需技能,但这种潜力尚未实现。

以生命周期为导向的部署可以定义为社区中许多人的最终目标。它指的是一个能够自主探索、开发新技能并在不熟悉的世界中运行的智能体。今天,许多以这个方向为导向的项目正在“测试床”上对 Minecraft 进行有趣的研究。事实上,Minecraft 代表了一个虚拟世界,在这个世界中,模型必须执行短期和长期的任务(在这些设置中,拥有记忆很重要,我们将在下一章中进一步讨论)。

图 4.8 – 单个基于 LLM 的智能体在日益复杂的场景中的实际应用 (https://arxiv.org/pdf/2309.07864)

图 4.8 – 单个基于 LLM 的智能体在日益复杂的场景中的实际应用 (arxiv.org/pdf/2309.07864)

然而,人类不仅从书籍中学习,还从其他人那里学习。此外,我们的大部分工作都是协作完成的。也因为资源问题,劳动分工要方便得多。因此,一些研究人员提出,应该遵循与 AI 相同的途径。在多智能体系统(MASs)中,不同的智能体相互协作并相互沟通。几个 LLM 智能体以自然语言(这意味着它们的行为也可以被人类观察者解释)进行协作和沟通。在这种情况下,也可以有多个专注于特定任务的 LLMs,而不是必须使用一个专注于所有事物的模型。实际上,一些方法侧重于创建互补的智能体,它们可以协作和共享信息。在这些设置中,模型也可以做出集体决策,并且能够解决单个智能体无法解决的问题。例如,为了提高过程的分辨率,智能体可以提供不同的响应并进行多数投票。可能有提供反馈或监控其他智能体行为的智能体。这些交互可以是有序的(遵循规则或具有顺序性)或混乱的(每个智能体都可以表达自己的意见)。

智能体无需合作。根据博弈论,利用智能体之间的竞争对任务解决可能有益。这个过程已被用于训练模型以赢得游戏。实际上,AlphaGo (www.nature.com/articles/nature24270) 被训练以在围棋中战胜自己,因此它能够积累更多的游戏时间。LLMs 可以被置于所谓的对抗性设置中,其中它们从另一个智能体那里获得反馈并利用它来提升自己。有几种方法,你可能让智能体讨论或反思另一个智能体的表现:

图 4.9 – 多个基于 LLM 的智能体的交互场景 (https://arxiv.org/pdf/2309.07864)

图 4.9 – 多个基于 LLM 的智能体的交互场景 (arxiv.org/pdf/2309.07864)

智能体还可以与人类(人-智能体交互)进行交互。这假设了对智能体行为的控制,以便他们的目标与人类的目标一致。同时,与人类的交互是重要的信息来源,应该被利用来为智能体提供反馈(性能、安全性和潜在的偏见)。此外,与人类的交互还可以是一种让智能体进化的方式。

我们可以在智能体和人类之间有两种类型的交互:

  • 不平等交互,也称为指导者-执行者范式,是一种人类通过自然语言提供指令而智能体执行的方法。这种对话可以是单一提示(指令和执行)或交互式(对话)。在这种方法中,智能体执行,而人类提供指令和反馈。在最简单的格式中,反馈可以是定量的(二元或评分)或定性的(自然语言、建议、建议或批评),模型可以使用这些反馈来改进当前和未来的响应。这种方法的一个子分支,称为持续学习,研究模型如何通过每次交互进行学习。

  • 平等交互是一种智能体与人类之间存在平等伙伴关系的范式。鉴于当前 LLM 的对话能力,智能体可以为人类提供协作角色。这种方法的局限性之一是缺乏聊天机器人的情感,这被用户视为问题。因此,一些研究人员专注于使聊天机器人更具同理心。此外,这些智能体在与人类互动之前需要更好地理解信念和目标,才能在互动中获得平等的地位。

图 4.10 – 人类-智能体交互的两种范式 (https://arxiv.org/pdf/2309.07864)

图 4.10 – 人类-智能体交互的两种范式(arxiv.org/pdf/2309.07864)

在下一节中,我们将讨论创建智能体的主要库。

探索主要库

在概念和理论层面上讨论了各种组件和框架之后,在本节中,我们将讨论一些主要的库,这些库使得这些概念得以付诸实践。这些库使得将 LLM 连接到各种附加模块成为可能。LLM 仍然是核心,但因此连接到感知模块和执行工具。在接下来的章节中,我们将详细阐述一些方面,并展示不同的实际例子。

通常情况下,基于 LLM 的应用结构包含几个组件:

  • 界面:这连接用户到系统。

  • 大脑:一个可以连接额外记忆的 LLM。LLM 拥有自己的参数化记忆(在训练期间获得),但我们还可以添加外部记忆(例如向量数据库或知识图谱)。

  • 感知模块:这些模块允许摄取和转换用户数据。

  • 工具:扩展 LLM 能力的模块。这些模块可以在库中构建或由开发者创建。

  • 提示词:用户与应用程序在自然语言中的对话。提示词包含用户提供的指令(前端提示词)以及用户看不到的信息(后端提示词)。后端信息是条件化 LLM 行为的额外指令。例如,我们可以强制 LLM 只使用上下文中的信息或向量数据库中的信息进行响应。一些后端提示词是为了防止模型以有害内容进行响应而开发的。

有几个不同的库使我们能够构建这样的系统,以下我们将介绍以下内容:

  • LangChain

  • Haystack

  • LlamaIndex

  • Semantic Kernel

  • AutoGen

让我们逐一看看它们。

LangChain

LangChain是一个以 LLM 为核心开发应用程序的框架。这个框架的重点是这些应用程序的开发和部署到生产环境。LangChain 生态系统由三个核心组件组成:

  • LangChain:不同的模块允许将具有附加内存、提示词和其他工具的 LLM 集成

  • LangSmith:这个组件用于检查、监控和评估你的应用程序

  • LangServe:这允许你将你的系统转变为 API

LangChain 可以在 Python 和 JavaScript 中使用(并且一些模块也适用于 Rust)。到目前为止,它是社区中最广泛使用的库之一,实际上,已经有一些组件是由开源社区开发的。

LangChain 与闭源模型(如 OpenAI 或 Anthropic)或 Hugging Face 上可用的模型兼容。LangChain 以开发为导向(LangChain 的一个优点是它允许并行执行和异步支持),是构建需要投入生产的应用程序的最佳库之一。LangChain 为 LLM 提供了方便的包装器,并允许它们连接到额外的工具。最有趣的一点是,它允许你构建所谓的链(LLM 和附加组件),然后可以在生产环境中跟踪和部署。LangChain 还提供了一些函数来转换不同的数据(CSV、PDF、文本、图像等)。此外,该库提供了一系列提示词模板,以更好地使用各种 LLM。

LangChain 通过创建模块化抽象,从而使得模型能够高效地连接到工具。通过构建链,你可以创建高效(但仍然灵活和定制)的管道,然后可以轻松部署。此外,通过 LangSmith,你可以监控系统以避免问题。

LangChain 有几个优点:

  • 综合库:它提供了一个广泛的特性库,为许多应用程序提供了现成的模板。此外,设计是模块化的,因此你可以轻松地交换组件。

  • 广泛的集成:LangChain 提供了一种简单的方式连接到大量的外部库:LLM 提供商、向量数据库、云服务等。

  • 精确且清晰的流程:LangChain 使得可以清楚地定义输入和输出,并允许监控链中的中间产品以及进行广泛的提示工程。

  • 活跃的开发社区:有一个庞大的用户基础,社区已经开发出不同的解决方案,并在各种网站和论坛上编写了许多教程。

  • 专注于端到端周期的灵活框架:LangChain 提供了应用程序整个周期的元素(集成、开发、部署和可观察性)。

同时,它也有一些缺点:

  • 更陡峭的学习曲线:用户可能需要更多时间来适应库的语法并实现库的全部功能。抽象能力是有代价的;所有功能都定义为类。例如,一个简单的提示必须抽象成一个提示模板。

  • 文档:许多用户抱怨文档过时或难以理解,过于通用但缺乏专业性。通用性也是一个缺点,因为对于几个特定的应用,有更多的系统具有更多功能(例如,对于 RAG 应用)。

LangChain 是最广泛使用的库,特别是用于构建复杂代理。然而,它也有最陡峭的学习曲线。因此,许多项目用户通常更喜欢一个更简单的库。

干草堆

干草堆是一个用于构建生产就绪型 LLM 应用程序的开源框架。与 LangChain 类似,它兼容主要的 LLM 来源和部署平台。干草堆还允许您将工具连接到 LLM,并有一整套工具旨在将系统投入生产(包括评估、监控和数据摄取)。它旨在能够轻松创建具有相关外部存储、聊天机器人和代理的 LLM,以及多模态系统。干草堆的一个优点是它具有几个预构建的功能,可以轻松地插入到自己的管道中。

干草堆建立在一切都可以轻松组合的理念之上,主要元素如下:

  • 组件:这些是专门用于文档检索、文本生成或创建嵌入的构建块。这些组件可以被视为节点,库提供了许多已经构建并准备好使用的节点。用户仍然可以选择创建自己的节点。

  • 管道:这些是理解应用程序中数据流的一个方便的抽象。一个管道由几个连接的组件组成。Haystack 通过允许灵活的管道控制(你可以连接管道、创建循环等)来简化系统。在 Haystack 中,你可以将它们视为组件作为节点可以以复杂方式相互连接的图。

Haystack 有几个优点:

  • 专用组件:Haystack 提供了用于数据处理、嵌入、排名和编写的许多优秀组件。此外,该库专注于搜索和问答(Q&A)系统。对于这个用例,它提供了优化的组件。

  • 广泛的文档和社区:Haystack 被一个大型社区采用,现在有许多社区开发的组件。它还提供了高质量的文档,有许多教程。

  • 更平缓的学习曲线:Haystack 被认为是一个易于学习的框架。它很灵活,很容易适应不同的情况。

然而,它也有一些缺点:

  • 较小的用户基础:社区很活跃,但比 LangChain 或 LlamaIndex 等其他框架要小。

  • 较少的集成:与其他框架相比,集成的数量较少。尽管如此,该系统是灵活的,存在许多自定义工具。

  • 更窄的范围:Haystack 更专注于检索和文档理解任务,因此它为其他 NLP 应用程序提供的工具和解析器较少。当你需要开发包含对话、聊天机器人或其他工具的应用程序时,这是一个限制。

  • 可扩展性:许多用户在需要扩展系统或处理大量数据集时都会遇到问题。

Haystack 是一个易于使用的库,对于基于 RAG 的应用程序来说是一个很好的选择,但对于涉及代理的更复杂的应用程序来说则不那么理想。

LlamaIndex

LlamaIndex 是另一个专注于围绕 LLM 构建系统的框架。LlamaIndex 最初是一个数据框架,专注于构建 RAG。因此,该系统具有多个数据连接器,既可以集成外部来源,也可以摄取不同类型的数据。LlamaIndex 的一个有趣之处在于它允许知识图轻松集成。它还可以与不同类型的模型集成,但它也提供了与其他框架(Docker、OpenAI、LangChain、Flask 等)的集成。

LlamaIndex 可以用来敏捷地构建聊天机器人并将它们与外部存储连接起来。它还允许你构建能够搜索互联网或执行操作的自主代理。已经构成了一些工具和功能,还有其他由其社区开发的功能。

LlamaIndex 也具有几个优点:

  • 处理不同的数据源:LlamaIndex 可以处理超过 160 种数据源,使其在处理企业中常见的多种类型数据时效率很高。当拥有复杂且多样化的数据集时,它尤为理想。它还支持多模态集成。

  • 索引和高效检索:这是 LlamaIndex 的优势;它旨在准确快速地检索信息。该库为 RAG 和其他检索范式提供了多种工具和功能。

  • 定制:特别是在检索方面,LlamaIndex 提供了高度的可定制性。

也有一些缺点:

  • 复杂性:与其它框架相比,LlamaIndex 的学习曲线较为陡峭。为了最佳使用,它假设你有一个清晰的信息检索概念。

  • 功能有限:LlamaIndex 专注于检索任务,但在其他 NLP 任务方面的功能有限。这导致缺乏多功能性。

LlamaIndex 是 RAG 应用的首选,也是智能代理的良好解决方案。

语义内核

语义内核是由微软开发的开源框架,用于构建智能代理。此库还可以与 OpenAI、Hugging Face 和其他框架连接。Semantic Kernel 最初是用 C#编写的,但今天也有 Python 版本。这个库背后的理念是提供创建组合各种函数(也称为函数组合)的能力。换句话说,语义内核建立在各种组件可以组合在一起构建多功能管道的理念之上。

在语义内核中,核心是一个 LLM,但我们可以添加我们开发的代码作为插件,以便 LLM 可以执行它。此外,它允许 LLM 拥有可以以文件或向量数据库形式存在的内存。一个有趣的因素是,可以创建专门执行任务的本地函数。它还实现了一个规划器,该规划器将你的任务作为输入,并返回一组动作、函数或插件以成功解决任务。

语义内核功能多样,支持多个库,并对 C#和.NET 框架提供轻量级支持。它受到 Copilot 框架的启发,该框架稳定且是企业的好选择。

自动生成

UserProxyAgent(从用户收集信息并将其传递给其他代理),AssistantAgent(从另一个AssistantAgent实例和UserProxyAgent接收数据,处理它并完成任务),以及GroupChatManager(控制和指导代理之间的通信)。AutoGen 支持多种复杂的对话模式,允许在没有人为干预的情况下进行复杂的流程。涉及多个代理以复杂方式相互通信的系统可以配置。

此库有以下优点:

  • 简单性:抽象使得可以直观地了解代理如何进行对话并完成任务。此外,这也使得向非技术人员和其他利益相关者解释系统变得更加容易。

  • 定制性:过程直观,并且可以通过少量代码轻松定制。

然而,也有一些缺点:

  • 更难调试:代理相互依赖,这使得调试变得困难

  • 支持较少:它不太被社区采用,因此当你需要帮助时,可供求助的用户较少

AutoGen 是一个有趣且具有潜力的库,但在这个阶段,用它开始一个项目可能会有点困难。

选择一个 LLM 代理框架

通常,不同的框架提供类似的功能,并受到相同哲学的启发(扩展 LLM 的能力)。此外,今天几乎所有的库都相当成熟,并且有专门构建的组件。对于库中未原生存在的功能,今天有许多由社区构建的资源。主要组件是 LLM,LLM 的能力是那些最影响应用程序结果的因素。

影响选择的第一因素可能是库的编程语言。通常,这些库必须集成到无法修改的现有系统中。几乎所有的库都是用 Python 编写的,但也包含可以用其他语言编写的模块,这有助于它们的集成。在某些情况下,尽管支持不是原生的,但已经被开源社区开发出来。例如,LangChain 支持 Rust,在其他语言(如 C#、R 等)中也有非官方的实现。系统必须完成的任务也是另一个决定因素。系统的复杂性增加要求框架同时具备鲁棒性和灵活性。一些系统设计时更注重信息检索(LlamaIndex),因此如果我们的系统要专注于聊天和检索,它们是更好的选择。在其他情况下,我们更关注系统的可扩展性和性能,因此我们可能会对 LangChain 和 Haystack 提供的所有监控和评估生态系统感兴趣。

此外,希望有一个活跃的开发者社区,并且库本身也要积极维护。当采用一个框架时,重要的是要有资源和社区可以求助,以避免陷入困境或找不到解决方案。一个社区采用的库将拥有大量的教程和示例,帮助你学习系统。

另一个因素是定制化程度。尽管所有库都提供预定义的功能,但这些功能并不涵盖所有用户场景,并且需要开发内部解决方案。理想的库应该具有这种多功能性和修改和集成组件的能力。可能发生的情况是我们想改变我们的 LLM 或其中一个组件,因为我们需要不同的性能。同样,默认参数可能不适合我们的应用程序,并且最好有一个库,其中调整参数并不复杂。

最佳库主要取决于用例。每个库都有其优势和劣势。例如,如果应用程序侧重于检索,LlamaIndex 可能是最佳选择,或者如果应用程序的核心是问答,则 Haystack 可能是更好的选择。LangChain 对于广泛的范围是一个更自然的选择,但如果系统要集成到.NET 中,您可能会选择 Semantic Kernel。选择的框架应该考虑额外的约束以及应用程序的主要关注点。

我们现在已经看到了 AI 代理最重要的库。在下一节中,我们将开始测试它们在实际中的应用。

创建一个搜索网络的代理

我们通常将互联网搜索与像 Google 这样的搜索引擎联系起来。查询的搜索是通过算法进行的,但这不是人工智能算法。PageRank 实际上是一个不涉及学习的图搜索算法。搜索算法预设了两个主要步骤:

  • 匹配:找到与特定用户查询相关的文档

  • 排名:将这些文档按相关性从高到低排序

这两个步骤不一定需要人工智能。然而,使用人工智能进行搜索可以提供更好的服务并解决一些困扰搜索算法的问题。现在的用户期望人工智能算法能够区分实体和术语,并将其置于上下文中进行定位。例如,搜索“最好的比萨饼店”的用户期望搜索引擎返回附近的最佳餐厅。未来的搜索过程也将整合其他元素,例如关于结果的对话、复杂的响应(摘要和行动),以及多模态。

另一个方面是,在今天的系统中,搜索结果在许多情况下应该是与用户相关的。搜索可能是模糊的,并且考虑到用户的历史记录,某些结果可能更为相关。此外,用户可能希望基于其他参数进行搜索,并希望用自然语言表达(例如,“巴黎最好的比萨饼店”与表达“最好的比萨饼店 AND 巴黎”之间的区别)。一旦找到结果,用户可能会有其他需要推理的问题(“这些比萨饼店中哪一家适合带小孩的晚餐?”)。

增强型搜索可以满足这些需求,因为它在其核心处有一个 LLM。LLM 可以理解查询中各种关键词之间的区别,以及理解用户正在寻找哪个领域(例如,“Transformer”可以是一个 AI 模型或玩具)。此外,通过访问先前交互的历史记录,LLM 了解用户的偏好(因此你不必每次都声明你的偏好)。这使得结果的相关性排名更加相关,因为它们不仅按查询排序,还按用户的偏好排序。模型还可以进行推理,并给予更隐含相关的结果更高的权重(例如,当搜索家庭餐厅时,即使描述中未明确指出是为家庭设计的,多模态模型也会更倾向于有游乐场图片的餐厅)。用户还可以通过代理向结果和模型提出问题。

传统搜索按查询的重要性顺序返回链接。然而,今天,信息可以从网站中提取并由 LLM 分析。对于给定的查询,模型现在可以提取网站中最相关的段落(提取式问答)或提出直接回答查询的第一结果的摘要(抽象式问答)。这样,用户甚至不需要点击链接,就能直接获得答案。然后,这个系统可以与其他工具集成,例如外部存储(如 RAG 和知识图谱,我们将在下一章中看到)。

此外,LLM 具有生成能力,因此这些可以与查询结合使用(例如,“搜索法国大革命的资料”或“搜索用于卷积的 Python 代码并将其翻译成 R”)。这种类型生成搜索的一个问题是幻觉风险,因此系统必须保留它所使用的来源,以便可以进行回溯。

在使用 LLM 和代理的最简单搜索形式中,我们有一个连接到界面的 LLM,它允许接收查询,以及一个允许它搜索互联网的工具。在这个基本案例中,LLM 必须分析查询,计划使用工具搜索互联网,分析找到的结果,并回答查询。在更复杂的形式中,LLM 可能拥有更多可用的工具。例如,它可以执行代码、计算器和外部存储来保存数据或调用执行 NLP 任务(如文本中的实体识别、提取段落等)的模型。

图 4.11 – LLM 代理互联网研究系统的表示

图 4.11 – LLM 代理互联网研究系统的表示

让我们分解 图 4.11:

  1. 用户提出查询。

  2. 模型分析查询并计划执行操作。

  3. 选择合适的工具(在这种情况下,互联网搜索)。

  4. 文档在互联网搜索过程中被识别。信息被发送回模型,模型分析信息并决定是否需要进一步行动或任务是否已完成。

  5. 模型生成答案,并将其发送回用户。

LangChain 允许 LLM 通过使用工具连接到网络。通常,最广泛使用的方法被称为推理与行动(ReAct)提示。在第一阶段(推理)中,模型考虑最佳策略以到达答案,在第二阶段(行动)中执行计划。在此方法中,模型还跟踪推理步骤并可以引导它到达解决方案。这种方法也允许灵活性,因为它使模型能够根据其需求调整提示。

就其本身而言,LangChain 提供了一些旨在扩展模型并找到所需信息的工具。例如,它提供了几个用于搜索互联网的工具。DuckDuckGo 工具允许人们使用 DuckDuckGo 搜索引擎。这个搜索引擎是免费的,不跟踪用户数据(它还过滤掉充满广告或仅为了在谷歌搜索引擎中排名靠前的页面)。

为了使用它,我们需要安装一个特定的 Python 库,然后将工具导入到 LangChain 中:

!pip install duckduckgo-search
from langchain.tools import DuckDuckGoSearchRun
ddg_search = DuckDuckGoSearchRun()
ddg_search.run('Who is the current president of Italy?')

注意

您可以直接使用该工具,它将为您提供搜索结果。

LangChain 的一个优势是能够构建一个工具列表,然后由 LLM 使用。为此,我们必须给出一个名称,解释要执行的功能,并提供描述。这样,LLM 就会知道在它需要进行网络搜索时可以使用哪些工具:

from langchain.agents import Tool
tools = [
   Tool(
       name="DuckDuckGo Search",
       func=ddg_search.run,
       description="A web search tool to extract information from Internet.",
   )
]

可以使用 Google Serper,这是一个低成本 API(尽管有一些限制),允许您使用谷歌搜索引擎(您必须注册serper.dev/以获取 API 密钥);然而,这项服务需要付费。实际上,谷歌 API 的费用更高,LLM 无法直接访问搜索引擎(Serper 允许我们通过他们的 API 使用谷歌搜索引擎,并且他们提供一些免费信用额):

#!pip install google-serp-api
import os
SERPER_API_KEY = 'your_key'
os.environ["SERPER_API_KEY"] = SERPER_API_KEY
from langchain.utilities import GoogleSerperAPIWrapper
google_search = GoogleSerperAPIWrapper()
tools.append(
   Tool(
       name="Google Web Search",
       func=google_search.run,
       description="Google search tool to extract information from Internet.",
   )
)

此外,我们还可以将维基百科添加为可靠的信息来源:

from langchain.tools import WikipediaQueryRun
from langchain.utilities import WikipediaAPIWrapper
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
tools.append(
   Tool(
       name="Wikipedia Web Search",
       func=wikipedia.run,
       description="Useful tool to search Wikipedia.",
   )
)

一旦我们有了各种工具,我们就可以初始化一个代理并执行查询:

from langchain.agents import initialize_agent
agent = initialize_agent(
   tools, llm, agent="zero-shot-react-description",
   verbose=True
)
agent.run('Query')

模型将选择哪些结果对我们查询感兴趣。模型可以访问不同的信息,但没有地方可以保存它们。使用大型语言模型进行网络研究可以适用于不同领域(从医学到金融)。例如,模型已被用于访问基因序列并进行比较,或搜索有关药物、化学结构等信息。同样,模型可以搜索最新的财经新闻。另一个工具可以是OpenStreetMap(OSM)搜索。

在下一章中,我们将讨论模型如何保存和访问这些记忆。例如,我们可能希望我们的模型能够访问对话历史或扩展其知识。这在商业应用中非常有用,在金融和医疗保健等领域也是如此。

摘要

在本章中,我们介绍了如何使一个大型语言模型(LLM)成为复杂系统的“大脑”。我们可以利用 LLM 的对话和推理能力来解决任务。正如我们所说,这个大脑可以通过提供感知系统(感官)和工具(双手)来扩展。实际上,我们可以通过连接 API 来允许模型搜索互联网,也可以从其他模态(音频、图像或视频)中摄取信息。同样,模型使用这些接收到的信息来解决用户任务。如果我们能够想象到今天代理执行和自动化为用户执行常规任务,那么想象一个代理以越来越复杂和高级的方式与人类和其他代理互动的世界并不困难。

在下一章中,我们将看到模型如何拥有记忆,以及如何存储信息并能够再次找到它以提高效率。

进一步阅读

第五章:使用 RAG 扩展您的代理以防止幻觉

在前面的章节中,我们了解了什么是 LLM(大型语言模型),在前一章中,我们看到了它如何控制不同的工具以成功完成任务。然而,LLM 的一些局限性阻止了它们在医学等敏感领域的应用。例如,LLM 在训练时结晶其知识,而医学科学等快速发展领域使得这些知识在短时间内变得过时。随着 LLM 的使用,另一个出现的问题是它们经常会产生幻觉(产生包含事实或概念错误的答案)。为了克服这些局限性,一个新的范式已经出现:检索增强生成(RAG)。正如我们将在本章中看到的,RAG 允许 LLM 引用模型外部的记忆;因此,它允许找到并保持知识更新。同样,为模型的响应提供上下文指导可以减少幻觉。因此,RAG 今天被广泛使用,并被认为是具有前景的系统。

在本章中,我们将讨论这个系统是如何演变的,从如何使用 transformer 来查找信息开始。我们将详细讨论系统的各个组成部分(嵌入、向量数据库和生成)。

在本章中,我们将讨论以下主题:

  • 探索简单的 RAG

  • 检索、优化和增强

  • 评估输出

  • RAG 与微调的比较

  • 使用 RAG 构建电影推荐代理

技术要求

大部分代码可以在 CPU 上运行,但更倾向于在 GPU 上运行。代码是用 PyTorch 编写的,大部分使用标准库(PyTorch、Hugging Face Transformers、LangChain、SentencePiece、Datasets 和 scikit-learn)。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr5。

探索简单的 RAG

信息检索是处理在媒体中(通常是文本,但也可能是多模态)查找信息的科学领域。例如,用户可能感兴趣的是查找整个文档或文档中的片段;这项任务对于问答系统至关重要,其中模型必须找到回答用户问题的步骤。系统的核心是一个搜索引擎。在 RAG 的情况下,搜索引擎是一个转换器(或至少是一个语言模型),在本章中,我们将重点关注这一点。我们将讨论一个系统,其中我们有一个文档集合(文本的,但也可以是网页、图像、视频,甚至是代码或简短文本段落),这些文档在数据库中有相应的索引。这些文档可以与元数据(描述作者、大小、主题和关键词的属性)相关联。按照惯例,术语被定义为文本中存在的单词,也是一个可以回答搜索的段落。用户产生一个查询,它可以表示为术语。检索系统的目的是将查询与集合中的相关文档最佳匹配。然后,这些文档按相关性顺序返回。

图 5.1 – 工作流程图,展示了查询是如何被搜索引擎处理的

图 5.1 – 工作流程图,展示了查询是如何被搜索引擎处理的

让我们分解一下我们在图 5.1 中可以看到的内容。一个文档集合(A)被索引(B),并有序地输入到数据库(C)中。每个文档都被分配了元数据和索引。用户查询(D)被处理(E)以获得向量表示(F)。在搜索过程中使用的结果向量用于找到最相关的文档(G)。系统按相关性顺序返回文档(H)

如我们所观察到的,系统使用的是向量空间中的搜索。在最简单的形式中,这可以是词袋模型或我们在第一章中看到的 TF-IDF。例如,我们可以取一组文档并计算 TF-IDF。一旦我们完成了这个,我们就可以计算每个文档与查询之间的分数(通常是余弦相似度),并根据分数进行排名。对于一个文档 d 和一个查询 q 的向量形式,我们使用以下公式:

cosq,d=q∙dqd

我们可以在这里看到这个过程的例子:

图 5.2 – 使用 TF-IDF 检索最相关文档的示例

图 5.2 – 使用 TF-IDF 检索最相关文档的示例

这种类型的研究也需要适合的数据存储设施。例如,对于 TF-IDF(或衍生算法),使用倒排索引作为数据结构。倒排索引是一种专门设计来使在文档集中搜索术语变得高效的数据库结构。它由一个字典和帖子组成。字典指示术语的频率以及它们在哪个文档中找到。这样,给定查询中的一组术语,我们可以有效地找到包含它们的文档并计算相似度。

图 5.3 – 倒排索引示例

图 5.3 – 倒排索引示例

BM25 是 TF-IDF 的一个变体,其中增加了两个参数:b,它控制文档长度归一化的重要性,以及 k,它控制 词频(TF)和 逆文档频率(IDF)之间的关系。

BM25score=∑tϵqlog(Ndft)⏞IDFtft,dk(1−b+b(|d||davg|))+tft,d⏞TF

前面的公式是针对文档 d 和查询 q 的 TF-IDF 变体(d avg 表示文档的平均长度)。

图 5.4 – k 和 b 参数对 BM25 分数的影响

图 5.4 – k 和 b 参数对 BM25 分数的影响

我们可以观察到一些有趣的观点:

  • 通过选择 k 等于零,不使用 TF 计算分数。TF 成分变得无关紧要;分数不考虑一个术语在文档中出现的频率,只考虑它是否出现。更高的 k 值赋予 TF 更大的权重。k 用于调整 TF 饱和度 – 换句话说,单个查询术语对单个文档分数的影响程度。b=1 表示对文档长度进行归一化,而 0 表示消除归一化。

  • 系统对 TF 和文档长度都很敏感,而无需添加太多参数。通常推荐值为 b=0.75 和 k 在 1.2 到 2 之间。BM25 比 TF-IDF 更灵活,可以适应不同的场景。

  • 它并不比 TF-IDF 复杂多少,因此可以扩展到大型数据集,并且对稀疏矩阵更稳健。

并非总是容易找到精确数据集的最佳参数。模型对超参数的选择很敏感。BM25 由于基于词频,对语义的理解有限。此外,许多术语是多义词(具有多个含义),而 BM25 没有捕捉到术语的上下文。另一个严重的问题是词汇不匹配问题——即查询和文档中的术语没有完全重叠。

解决这些问题的方法是使用包含上下文信息的密集向量。这是通过使用转换器并提取文档的表示来实现的。更正式地说,给定一个标记序列,我们使用来自最终层的表示 z。这使我们能够获得一个高维表示,我们可以用它来区分单词的意义。这被称为 z 分数。

图 5.5 – 单词“bank”的上下文嵌入

图 5.5 – 单词“bank”的上下文嵌入

图 5**.5 展示了不同语境下(包括金钱和河流相关含义)单词“bank”的上下文嵌入的 t 分布随机邻域嵌入(t-SNE)可视化。t-SNE 是在每个句子的单词 BERT 嵌入上进行的。

有几种方法可以从模型中检索这个表示。为了方便起见,使用最后一层,但通常建议对多个层的表示进行平均池化(每个块由于自注意力而学习不同的文本表示)。正如我们在 第一章 中所看到的,这些向量具有几何属性,可以用于操作(聚类、相似度计算等)。

通常,会对嵌入进行一些转换以优化其使用。例如,对向量进行归一化(z 分数或其他方法)。事实上,由于各向异性,许多单词的向量是相似的。实际上,随机选取单词时,余弦相似度高于应有的水平。这是由于异常维度,少数几个维度(1–5)由于具有高幅度和不成比例的高方差而主导上下文嵌入。这导致在降低的嵌入空间上计算相似度。这些异常维度与绝对位置和标点符号高度相关,因此是无信息的。z 分数等转换可以减少这个问题。

图 5.6 – 各维度对余弦相似度的相对贡献 (https://aclanthology.org/2021.emnlp-main.372.pdf)

图 5.6 – 各维度对余弦相似度的相对贡献 (aclanthology.org/2021.emnlp-main.372.pdf)

此外,检索嵌入中每个单词的嵌入是不必要的繁琐。对于双向编码器,我们可以使用两种主要策略:使用单个编码器或双编码器。在第一种情况下,我们向模型提供查询和文档,从而允许双向自注意力关注所有标记。该表示将代表查询和文档。使用的格式是 [CLS]-query-[SEP]-document。然后,将 [CLS] 标记的表示输入到线性层以产生相似度得分(此层经过微调)。通常,这个过程不是针对整个文档,而是针对一系列块(文档的非重叠片段),因为文档通常比上下文长度长(对于 BERT,这是 512 个标记,所以查询和文档的总数不得超过 512 个标记)。

这个系统成本很高,因为它要求我们必须传递一个查询以及整个文档语料库。为了降低成本,实现了一个称为双编码器的更高效架构。一个编码器用于提取查询的表示,[CLS]q,另一个用于提取每个文档(或块)的表示,[CLS]d。基本上,对一个语料库进行操作,我们计算语料库中每个文档的嵌入,并将这种表示存储在数据库中。之后,我们计算查询表示与数据库中所有向量的余弦相似度。这个系统速度更快,但准确性较低,因为其中一部分交互是在查询和文档中的术语之间。

图 5.7 – 两种不同的上下文嵌入方法

图 5.7 – 两种不同的上下文嵌入方法

让我们更详细地考察 图 5.7。 [CLS] 表示。 [CLS] 表示用于查询和所有向量。我们使用这两种表示来计算余弦相似度。

然后,我们可以对整个语料库进行嵌入,并在数据库中索引文档,然后,当有查询时,计算相似度。

图 5.8 – 一组文档与两个查询之间的余弦相似度,其中“bank”一词的含义不同

图 5.8 – 一组文档与两个查询之间的余弦相似度,其中“bank”一词的含义不同

如我们之前提到的,生成模型可以产生幻觉。给定一个查询,LLM 可以生成包含错误信息的输出。这源于 LLM 在解释概念方面很擅长,但保留特定信息方面存在问题。在训练过程中,通过重复类似的信息来强化对概念的了解。这对于概念来说效果很好,但对于特定信息(如日期、数值和罕见信息)来说则效果较差。此外,数据集中包含正确和错误的信息,往往相互冲突。当模型生成响应时,它会从分布中进行采样,并必须从它所学习的信息中进行选择,从而导致幻觉。

此外,不正确的架构、过拟合或训练过程中的偏差也可能促进幻觉的产生。微调模型或过度优化某些任务可能是另一个原因。例如,优化模型以生成长文本输出会促使模型变得冗长并产生幻觉。同样,提高温度会增加采样的随机性,导致不太可能出现的样本标记,从而产生更多的幻觉。错误的提示也可能促进这种行为。

当在特定领域(如医疗保健、金融等)使用模型时,幻觉最为明显。模型缺乏最佳理解查询的上下文。这是因为模型是在大量标记上训练的,而这些标记并没有被限制在特定主题上。损失是在文本集上计算的,因此更多地基于一般知识而不是特定信息。因此,模型倾向于通用功能,但在应用于特定领域时表现较差。这是一个常见因素,与模型参数的数量无关。

已经测试了多种可能的解决方案来减少或防止幻觉。一种方法是将上下文作为 LLM 提示的一部分提供(当可能将所有这些上下文添加到提示中时)。然而,这意味着用户必须再次找到相关的上下文。当你有大量不同的文档时,这变成了一项复杂且费力的任务。另一种方法是微调,其中模型在特定文档上进一步训练。但这需要计算成本,并且如果出现新文档,应重复进行。

在 2020 年,Meta 提出了一种替代方法:为 LLM 提供的 RAG。这种方法假设通过在外部源(如数据库)中找到上下文来增强 LLM 的生成。这个数据库可以是特定领域的,并且可以持续更新。换句话说,我们找到回答查询所需的文档,并利用 LLM 在上下文中学习的强大能力。

图 5.9 – 显示 RAG 过程的图

图 5.9 – 显示 RAG 过程的图

在*图 5**.9 中,排名靠前的文档被纳入提示(查询、检索到的文档和附加信息),然后呈现给 LLM。LLM 使用附加上下文来响应用户的查询。

我们将来自 LLM 的知识定义为参数化记忆,而从 RAG 获得的知识则被定义为外部或非参数化。更正式地说,RAG 是一个系统,在其最基本的形式中,由三个部分组成:

  • 索引:索引处理从原始数据到存储在向量数据库中的整个过程。它始于以各种格式(PDF、HTML、Markdown 或 XML)摄取数据,这些数据必须转换为文本。文本根据选择的嵌入模型进行处理(它被分成比模型上下文长度小的块)。然后这些块被嵌入(转换为向量表示),分配一个标识符,并存储在向量数据库中。

  • 检索:当查询到达时,必须找到最相关的块。用于文档嵌入的相同编码器用于获取查询的向量。然后计算查询向量和存储在数据库中的向量之间的相似度得分。根据相似度得分选择前K个块。

  • 生成:找到的块与查询一起纳入用于生成的 LLM 的一致提示。不同的 LLM 可能需要提示中的不同元素才能最佳工作;同样,我们也可以有针对特定任务的定制提示。此外,我们还可以添加来自先前对话(历史记录)的元素。

对于自回归模型,我们可以修改在第二章中看到的方程,其中我们定义 LLM 计算给定前一个标记序列的概率:

px1,x2,…,xn=∏i=1np(xi|x<i)

对于问答任务,给定一个问题(或查询)q,我们可以将方程重写如下:

px1,x2,…,xn=∏i=1np(q;x<i)

在 RAG 中,我们还有额外的元素:提示 Pr、检索到的上下文 R 和问题 q,它们都被连接起来:

px1,x2,…,xn=∏i=1np(xi|Pr;R;q;x<i)

此过程在图 5.10中展示:

图 5.10 – RAG 过程及其步骤的代表性实例( https://arxiv.org/pdf/2312.10997 )

图 5.10 – RAG 过程及其步骤的代表性实例(arxiv.org/pdf/2312.10997)

这是通用架构,但也有更复杂的变体(我们将在下一章详细讨论)。为了完整性,这种架构的替代方案是跨度提取。在这种情况下,我们不是寻找最合适的块,而是使用一个语言模型(通常也是从 BERT 派生而来)来找到文本中回答查询的段落(跨度标记)。例如,如果我们的语料库是维基百科,我们的查询是“谁是法国总统?”,提取器将标记回答问题的页面(在 RAG 中,我们检索相关的文本块)。RAG(或跨度提取器)在减少幻觉和提升 LLM 在开放域问答(也称为开放式问答)能力方面显示出有趣的能力。

在下一节中,我们将更详细地讨论这些步骤,以及为了优化系统我们需要做出哪些选择。

检索、优化和增强

在上一节中,我们讨论了 RAG 的高级范式。在本节中,我们将详细查看组件,并分析实践者在实施 RAG 系统时可能做出的选择。

块划分策略

我们已经说明,在将文本嵌入数据库之前,文本被分为块。分块对搜索中包含的信息有很大影响。块太小会丢失数据的上下文,而块太大则不具体(并呈现无关信息,这也影响响应生成)。这会影响查询特定信息的检索。分块大小越大,引入提示的标记数量就越多,从而增加推理成本(但数据库的计算成本也随着每份文档中块的数量而增加)。过多的上下文也可能导致幻觉并降低大型语言模型(LLM)的性能。此外,块大小不能超过嵌入器的上下文长度,否则我们会丢失信息(这被称为截断)。换句话说,块大小是影响检索和生成质量的重要因素。

最简单的策略是基于固定长度的分块。字符分块根据预定的字符数或标记数将文档分为块(常见的选择是 100 或 256 个标记或 500 个字符)。大小应根据文档类型选择。这是最便宜且最容易实现的系统。一种变体是随机块大小,其中块的大小是可变的。当集合非同质时,可以使用这种变体,以捕获更多的语义上下文。分块可以是重叠的或不重叠的。不重叠的分块(图 5**.11)如果块之间存在清晰的边界(例如,如果上下文在相邻块之间发生剧烈变化)则效果良好。但这很少见,而且没有重叠会破坏上下文。然后可以使用滑动窗口,在块之间保持重叠。这个系统在块边界处保持上下文信息,允许更好的语义内容,并增加相关信息跨越多个块时被发现的机会。然而,这种策略成本更高,因为我们需要将其分成更多的块,因此我们将有一个具有更多条目的数据库。此外,一些信息是冗余的,因此重叠不应超过整个块大小的百分比。

图 5.11 – 在《哈姆雷特》摘录中使用不同分块策略的效果

图 5.11 – 在《哈姆雷特》摘录中使用不同分块策略的效果

在 图 5**.11 中,我们可以看到以下内容:

  • A): 基于标记数且不重叠的简单分块

  • B): 基于标记数和重叠的简单分块

  • C): 基于标记数和文本中新行存在与否的简单分块(基于字符)

上下文感知分块是一种策略,其中我们使用正则表达式(regex)将文本分成块。例如,我们可以根据句号、逗号或段落分隔来划分。这种策略的变体基于我们要划分的文本类型(例如,HTML 标签、Markdown 信息、XML、特定领域的符号等)。这个系统并非没有缺点;有时确定边界可能很困难(例如,对于复合句、脏文本等)。因此,你可能会有大小不一的块。一个更复杂的变体称为递归分块,其中块被分割的方式类似于上下文感知块。之后,这些块被合并到预定的标记数(例如,嵌入器的最大上下文长度)。这种方法试图将所有上下文相关的信息保持在同一个块中,并保持语义一致性(例如,如果可能的话,将属于一个段落的所有块合并)。或者,文本可以迭代地分割,直到块达到所需的大小。层次聚类是一种类似的方法,试图尊重文本的结构。通过检查文本中的关系,它试图将其分成尊重其层次结构的段(部分、子部分、段落和句子)。这个系统对于具有复杂且已知结构的文档很有用(例如,商业报告、科学文章和网站)。这种方法还使得检查获得的结构和理解各个块之间的关系成为可能。当处理格式不佳的文档时,这个系统工作得不好。

图 5.12 – 层次分块演示

图 5.12 – 层次分块演示

图 5**.12 展示了同一份文档在 Markdown(A)或 LaTeX(B)中的样子。使用特定的分块器,我们可以尊重语言结构进行分块。LangChain 使用层次聚类来实现这一点。

另一类方法是语义分块。这些技术的目的是考虑单词的上下文和意义。这些方法试图将文本中原本相距较远的分块(存在旁白或其他元素)进行分组。K-means 分块是一种方法,其中我们对各种句子进行嵌入,然后使用k-means 聚类将相似的句子分组到不同的簇中。这种方法需要设置最佳簇数(超参数)来选择,可能会导致句子顺序的丢失(可能存在对时间顺序或上下文关系的风险)。而不是考虑句子上的分割,基于命题的分块基于上下文理解进行分割。所谓的“命题”被识别为包含事实(如“法国的首都是巴黎”)的原子表达式。这些命题随后由一个 LLM 评估,根据语义一致性将它们分组。这种方法可以给出最佳结果,但计算成本高昂,并且依赖于所使用的 LLM 的选择。另一方面,统计合并评估句子嵌入中的相似性和差异性,以决定是否合并(或分割)它们。例如,在嵌入后,评估统计属性(标准差、百分位数或四分位数差异)的差异,如果它超过预定义的阈值,则将句子分开。这个系统创建了不同大小的分块,计算成本更高,但在句子之间的上下文边界不清楚时可以给出更好的结果。

最后,可能需要多模态分块。例如,PDF 文件可能包含文本和图像。在这种情况下,我们的分块管道需要能够提取图像和文本。

没有通用的最佳分块器——最佳分块器是我们特定情况最适合的分块器。尽管如此,我们可以建立以下指导方针:

  • 与文档结构对齐分块:文本结构在很大程度上影响分块大小和分块策略。在具有相同类型文档(HTML、LaTeX、Markdown 等)的情况下,特定的分块可能是最佳选择。如果它们是异构集合,我们可以创建一个根据文件类型进行分块的管道。

  • 优化性能和资源:如果我们有空间和计算成本的限制,一个简单的固定大小的分块器可能是一个最佳选择。语义分块在性能上略逊一筹,但更好地尊重信息完整性,并提高了找到的分块的相关性和准确性。然而,它需要了解文本内容,可能不是适用于普通用户使用的系统的最佳选择。上下文分块可能在性能上更好,但计算成本较高。

  • 尊重模型上下文限制:块大小应尊重上下文长度的维度。我们必须考虑到嵌入模型的大小以及我们将要使用的 LLM。

  • 将块分割策略与用户查询模式相匹配:考虑我们期望潜在用户向系统(RAG)提出的问题类型。例如,如果用户将要提出需要模型找到多个事实的问题,那么拥有小块但包含直接答案的策略会更好。或者如果系统更具有叙述性,那么拥有更多上下文的块会更好。

总之,开发人员必须检查在测试 RAG 系统的不同块分割策略时提供的文本和输出。在任何情况下,然后应该评估每种策略(在后面的章节中,我们将讨论如何评估它们)。

嵌入策略

正如我们之前看到的,嵌入是文本的密集向量表示(表示位于多维空间中)。我们利用这些向量来找到查询的适当上下文。我们可以有生成散点向量的编码器(如 TF-IDF 或 BM25)或生成密集编码器的编码器。如前所述,密集编码器是生成向量的 transformer。优点是这些模型是可训练的,因此可以适应查询和块之间的相似度任务。基于 BERT 的骨干是应用最广泛的之一;方法是创建两个并行的 BERT 编码器(两个流:一个用于查询,另一个用于块),称为双编码器方法。在最初的 RAG 方法中,这些权重是相同的(冻结的),我们只有一个层被训练来生成嵌入向量。拥有相同的权重使我们能够首先传递查询,然后是文档,然后计算相似度。另一方面,后来的模型对权重进行微调以提高模型生成更好嵌入向量的能力。

**图 5.13 – 用于生成嵌入向量的双编码器**

图 5.13 – 用于生成嵌入向量的双编码器

如图 5.13 所示的双编码器生成一个查询向量和文档向量。在这两个向量上,我们可以计算相似度。

或者,可以从零开始训练一个模型来完成这个任务。通常,最好使用一个未经监督训练的 LLM,然后对其进行嵌入和检索的适配。通常,这种模型是通过对比学习进行适配的。正如我们在第三章中看到的,对比学习是一种用于学习以嵌入形式表示的语义表示的技术。在第三章*中,我们使用了 CLIP,它是通过图像和标题进行训练的。在这种情况下,我们希望训练一个模型,生成嵌入,使我们能够找到与我们查询最相似的文档。最常用的数据集之一是多体裁自然语言推理(MultiNLI)语料库,它包含 433,000 个句子对,这些句子对带有文本蕴涵信息进行了标注。给定一个假设,第二个句子代表一个蕴涵、一个矛盾或两者都不是(中性)。

在对比学习中,我们需要正例和负例。在取了一个句子之后,我们希望我们的句子嵌入尽可能接近正例,并且与负例尽可能不同。在这种情况下,我们可以从 MultiNLI 中为我们的一个句子推导出正例和负例。实际上,蕴涵句子代表一个正例,而矛盾是一个负例。

图 5.14 – 包含可用于训练编码器的蕴涵或矛盾句子的示例

图 5.14 – 包含可用于训练编码器的蕴涵或矛盾句子的示例

一旦我们有了数据集,这些模型就使用适合任务的损失函数进行训练:

  • 1 表示相似句子(原始句子和正例)和 0 表示不相似句子(原始句子和负例)。作为损失函数,我们计算两个句子之间的相似度,然后将其与预测标签进行比较。

  • 多个负例排序损失:这是另一种流行的替代方案(也称为InfoNCE)。仅使用正例来计算这种类型的损失。在这种情况下,我们有原始句子和相应的正例(蕴涵句子)。对于负例,我们取原始句子和另一个句子的蕴涵句子。然后,我们计算嵌入和相似度。想法是最大化句子与其相关句子(其正例)之间的相似度,同时最小化与不相关例子(我们的负例)之间的相似度。通过这种方式,这个任务变成了一个分类任务,我们可以使用交叉熵。然而,负例是完全不相关的,因此这个任务对于模型来说可能太容易了(相反,最好添加相关但不是正确答案的负句子)。

选择嵌入器是一个关键决策,将对我们的系统性能产生重大影响。一个差的嵌入器会导致检索效果差,上下文与查询不相关,这反而可能增加幻觉的风险。编码器选择影响以下方面:

  • 成本:嵌入器是一个转换器。它越大,计算成本就越高。另一方面,封闭源编码器相对于 API 有成本,因此使用得越多,成本就越高。此外,嵌入文档和每个查询都与计算成本相关。

  • 存储成本:嵌入向量的尺寸越大,我们向量的存储成本就越高。

  • 延迟:更大的模型具有更高的延迟。

  • 性能:如果我们的主要关注点是性能,那么某些选择的花费是合理的。通常,更大的模型具有更好的性能。

  • 领域需求:现在有一些领域(如金融、医学、科学、编程等)有专门的编码器,其中一些是多语言的(大多数只支持英语,但其他支持多达一百种语言)。一些领域有不同的文本粒度,需要针对长文本进行专门设计的模型。

决定使用哪个编码器模型并不容易,这取决于各种因素。一个好的开始是 Hugging Face 上的 MTEB 排行榜(huggingface.co/spaces/mteb/leaderboard),这是一个编码模型及其在不同基准和任务上的性能的最新列表。然而,通常这些结果是自行报告的,并且是在标准基准上获得的(其中一些基准数据可能已泄露到训练数据中,从而高估了模型的能力)。因此,我们不应只选择一个模型,而应在自己的数据集上测试几个模型。然而,排行榜提供了一些重要信息,这有助于我们指导选择:

  • 检索平均数:计算多个数据集上的归一化折现累积增益(NDCG)(用于对检索系统进行排名的评价指标)

  • 模型大小:这让我们了解到使用该模型所需的计算成本和资源

  • 最大标记数:可以在上下文长度中使用的标记数

  • 嵌入维度:考虑嵌入后向量的大小

图 5.15 – 专注于嵌入模型及其性能的 MTEB 排行榜

图 5.15 – 专注于嵌入模型及其性能的 MTEB 排行榜

还应注意的是,排行榜在通用领域上进行衡量。这意味着它衡量的是一般性能,这可能导致我们在感兴趣的领域或任务中的性能不佳。

一旦我们选择了编码器,我们就可以在不影响性能的情况下降低这种成本。关于成本和可扩展性,对于向量嵌入的每个维度,如果它们以浮点格式存在,则需要 4 字节内存。这可能导致存储成本过高。在第三章中,我们讨论了量化——这也可以应用于嵌入模型。二进制量化(将模型减少到每个维度 1 位)可以将内存和存储减少高达 32 倍。最简单的二进制量化是使用零阈值:

fx=0ifx≤01ifx>0

然后,我们可以使用 float32 格式转换为 int8(一种使用 256 个不同级别表示值的格式)。如我们之前所述,这是通过在转换期间重新校准向量来实现的。

图 5.16 – 显示量化后内存减少的图表

图 5.16 – 显示量化后内存减少的图表

一种替代技术是套娃表示学习。深度学习模型倾向于在整个向量上分散信息;这种技术试图通过几个维度更少的表示来压缩信息。换句话说,它逐步减少向量嵌入的划分,同时不会损失太多性能。在套娃嵌入中,可以获得较小的嵌入,这些嵌入可以用作较大的嵌入。这是因为系统试图将最重要的信息存储在早期维度,而将不太重要的信息存储在后期维度(这样,我们可以在保持下游任务性能的同时截断向量)。为了训练编码器,我们为一批文本生成嵌入,然后计算损失。对于套娃嵌入模型,损失还考虑了不同维度嵌入的质量。这些值在最终损失中相加。因此,模型试图以最优化模型权重的方式,将最重要的信息(对于嵌入向量)定位在第一维度。

图 5.17 – 套娃与原始嵌入质量在维度数量上的基准比较

图 5.17 – 套娃与原始嵌入质量在维度数量上的基准比较

一旦我们有了向量,我们需要存储它们。在下一节中,我们将讨论存储它们的位置。

嵌入数据库

向量数据库是一种专门用于存储高维向量的数据库。因此,它针对处理非结构化和半结构化数据(如向量)进行了优化。该数据库的功能是允许高效地存储、索引和搜索。我们选择的向量数据库也会对 RAG 性能产生重大影响。如今,有数十种可能的向量数据库,因此选择最佳解决方案可能是一项艰巨的任务。幸运的是,有一些网站会对可能的系统进行对比。

图 5.18 – 向量数据库排行榜,解决向量数据库选择的一个实用来源 (https://superlinked.com/vector-db-comparison)

图 5.18 – 向量数据库排行榜,解决向量数据库选择的一个实用来源 (superlinked.com/vector-db-comparison)

可能没有最好的向量数据库,但肯定会有一个适合我们项目的。以下是一些可以指导我们选择的准则:

  • 开源或私有源:开源数据库提供透明度和定制系统的能力。它们通常有一个活跃的社区且没有相关成本。相反,私有源数据库可能是一个昂贵的解决方案,但通常有专门的支持。同样,检查许可证也很重要;它可能不适合您的产品。

  • 语言支持:向量数据库通常与主要的编程语言(Python、Java 和 C)兼容,但对我们项目来说,我们可能需要一个兼容其他语言(Rust、Go、Scala 等)的数据库。此外,并非所有数据库都与所有库兼容。因此,确保系统与我们的项目兼容是很好的。

  • 成熟度:特别是对于以生产为导向的项目,系统的稳定性、可扩展性和可靠性至关重要。同样,系统必须得到支持,被行业采用,并且需要经常维护。

  • 性能:这受两个参数的影响:

    • 插入速度:向量添加到数据库中的速率(这会影响延迟)。这特别影响实时应用或用户基数大的应用。一些数据库实现了批处理(各种数据包的有效分区)、并行化(任务在各个节点上的分布,对于云特别重要)或数据分区(数据集被分成段以同时进行插入和删除)等技术。

    • 查询速度:这指的是响应查询时找到向量的时间。这直接影响延迟时间。

    存在着诸如索引结构(构建索引以加快搜索速度)、缓存系统(频繁访问的数据被单独保存)或特定算法等优化技术。然后是特定产品相关的性能问题,例如可以向数据集发出的并发请求数量。法规遵从性和隐私问题也是关键。数据库应该能够允许差异化的访问(访问授权)并保护向量免受未经授权用户访问。

  • 组件集成:我们的系统除了 LLM 和嵌入器之外,还可以有多个组件(我们将在下一章中更详细地讨论这一点)。我们需要确保数据库可以与我们的编码器(以及我们用于编码器的库)集成。此外,并非所有数据库都接受其他组件,如再排序器、混合搜索等。

  • 成本:云解决方案可能具有非常高的成本,因此建议事先决定你的预算。成本还可能与保持系统运行所需的维护和支持相关。例如,向量是宝贵的数据,备份的成本可能会迅速增长。

例如,有些向量库是静态的(索引数据是不可变的),这使得添加新数据变得困难。例如FAISS(Facebook AI Similarity Search)并不是为创建、读取、更新和删除(CRUD)操作设计的,因此它们不适合有多个用户访问和执行操作的动态系统。相比之下,如果我们的数据库是不可变的,并且我们只授予访问权限,FAISS 可以是一个好的解决方案。有些 SQL 数据库允许支持向量(经典数据库的扩展)。这些数据库允许对相关元数据进行高效的索引。然而,这些数据库不可扩展,通常对向量大小(最大维度数)有限制,并且性能较低。SQL 数据库是连接到现有企业数据库(可能已经是 SQL)的内部项目的良好选择,但不是当可扩展性和性能很重要时的选择。

专门针对向量的数据库通常是最佳解决方案,尤其是在性能方面。实际上,它们通常实现了针对搜索和索引向量的专用和高效算法。其中一些算法是近似最近邻(ANN)算法的变体。ANN 通常在效率、存储和准确性之间提供了良好的权衡。近似搜索加快了搜索速度,同时试图保持准确性(HNSW(分层可导航小世界)牺牲了一些准确性,但比像 Flat 索引这样的准确算法快得多)。这些数据库也与主要语言和库(LlamaIndex、LangChain 等)兼容。

一旦我们的向量数据库用我们的向量填充完毕,我们需要评估我们的系统有多好。现在,我们将看看我们如何做到这一点。

评估输出

在信息检索中,我们感兴趣的是衡量找到的文档是相关还是不相关。因此,最常用的评估指标是精确率和召回率。精确率是检索到的相关文档的比例,而召回率是成功检索到的相关文档的比例。考虑一个查询,其中R代表语料库中所有相关文档,NR代表无关文档,Rq代表找到的相关文档,Dq是系统返回的文档。我们可以定义这两个指标如下:

precision=RqDqrecall=RqR

这两个指标的问题在于,它们不返回排名的好坏,只告诉我们是否找到了所有相关文档或总相关文档的百分比。通常,当我们使用检索器时,我们会选择一个数字(k)的文档作为上下文(top-k),因此我们需要一个考虑排名的指标。

图 5.19 – 假设在一个语料库中有五个相关文档,计算特定排名的精确率和召回率

图 5.19 – 假设在一个语料库中有五个相关文档,计算特定排名的精确率和召回率

我们可以使用精确率-召回率曲线来完成这个目的。每当我们在排名中找到一个相关文档时,召回率就会增加。另一方面,精确率随着文档的增加而增加,但每个无关文档都会使其降低。通过绘制一个曲线图,我们可以看到这种行为:

图 5.20 – 显示图 5.19 中数据的精确率和召回率的曲线图

图 5.20 – 显示图 5.19 中数据的精确率和召回率的曲线图

由于精确率上下波动,我们可以使用一个插值曲线。这个曲线不如曲线精确,但能更好地理解系统的行为(并且能够通过比较曲线来比较不同的系统)。

另一个使用的指标是平均平均精确率(MAP)。我们在检索到相关项的点处计算精确率值(平均精确率或AP),然后平均这些 AP 值。假设我们检索到了以下文档列表:[1, 0, 1, 0, 1],其中1表示相关,0表示不相关。每个相关项的精确率如下:

  • 第一份相关文档位于位置 1:精确率(N个相关文档检索到的总数/检索到的文档总数)= 1/1 = 1

  • 第二相关文档(位置 3):精确度 = 2/3 ≈ 0.67

  • 第三相关项目(位置 5):精确度 = 3/5 = 0.6

单个查询的平均精确度(AP)值是:

AP=∑precisionateachrelevantitemTotalnumberofrelevantitem<mi}s=∑(1+0.67+0.6)3=0.76

MAP 是所有查询的 AP 值的平均值。这里,我们假设我们有 3 个查询 – 0.76,0.5,和0.67:

MAP=∑averageprecisionforeachqueryTotalnumberofqueries=∑(0.76+0.5+0.67)3=0.64

一个特定于问答的指标是平均倒数排名(MRR)。MRR 旨在评估包含正确答案(通常为人工标签)的短排名列表的质量。倒数排名是第一个与问题相关的项目的排名的倒数。对于查询集Q,我们取倒数排名并计算平均值:

MRR=1Q∑i=1Q1ranki

或者,我们可以将生成后的响应作为分类任务来评估。

最近,评估 RAG 管道的一种新方法是使用一个大型语言模型(LLM)作为管道的评判者。通常,我们必须有一个包含真实数据的集合,以便 LLM 评估 RAG 管道是否找到了必要的步骤,并且生成的结果是否正确。例如,有一些不同的指标利用 LLM 作为评判者:

  • 忠实度:这个指标(也称为扎根性)衡量生成答案的事实一致性(范围在 0 到 1 之间)。如果一个答案中的陈述可以从上下文中推断出来,那么这个答案是忠实的。忠实度是生成答案中可以从上下文中推断出的陈述数量与生成答案中总陈述数量的比率。为了找到这些陈述,我们需要一个 LLM 来评估响应和上下文中的陈述。

  • 上下文召回率:这个指标指的是相对于真实数据找到的上下文量(范围在 0 到 1 之间)。理想情况下,系统应该找到真实数据中的所有句子。

  • 上下文精确度:这个指标衡量上下文中与真实数据相关的内容,这些内容被排序得更高(相关片段在检索后应该找到自己更高的位置)。

  • 上下文相关性:这个指标衡量上下文与查询的相关性。理想情况下,我们的系统应该只找到与查询相关的信息。

  • 上下文实体召回率:这个指标通过特别分析找到的实体来提供上下文召回的度量。换句话说,它衡量真实数据中上下文中找到的实体所占的比例。当我们对系统特别寻找实体感兴趣时(例如,上下文需要找到医疗实体,如疾病、药物或其他参数),这个指标很有用。

  • 答案正确性:这个指标侧重于批判性地评估答案是否正确。为了获得高分数,系统必须生成与真实数据在语义上相似但也是事实正确的答案。

  • 摘要分数:这个指标评估摘要如何捕捉上下文中存在的重要信息。答案是上下文的一种摘要,一个好的摘要必须包含重要信息。

  • 答案相关性:这个指标计算生成的响应对提示的相关性。低分意味着响应不完整或包含冗余信息。

  • 流畅度:这个指标评估生成单个句子的质量。

  • 连贯性:这个指标评估整个响应是否是一个连贯的语料库(避免响应成为一组不相连的句子)。

这些指标要求有一个评判者,这个人可以是人类或 LLM。它们不仅仅是统计值,还需要对响应(和/或找到的上下文)进行批判性评估。

RAG 也经常被讨论为微调的替代方案;因此,比较它们很重要,我们将在下一部分进行。

RAG 和微调的比较

RAG 和微调经常被比较,并被视为对立的技术。微调和 RAG 都有类似的目的,即向模型提供它在训练期间没有获得的知识。一般来说,我们可以这样说,有两种类型的微调:一种是为了适应特定领域(如医学、金融或其他)的模型,另一种是为了提高 LLM 执行特定任务或任务类的能力(如数学问题解决、问答等)。

微调和 RAG 之间存在几个差异:

  • 知识更新:RAG 允许直接更新知识(包括结构和非结构化信息)。这种更新对于 RAG 来说是动态的(信息可以实时保存和删除)。相比之下,微调需要重新训练,因为更新是静态的(对于频繁更改来说不切实际)。

  • 数据处理:对于 RAG,数据处理量最小,而微调则需要高质量的数据集(示例不足的数据集将无法帮助实现明显的改进)。

  • 模型定制:RAG 向 LLM 提供额外的信息,但不会改变其行为或写作风格。微调允许改变模型行为、写作风格,甚至新技能。

  • 可解释性:RAG 增加了系统的可解释性,并允许追踪响应和使用的来源。微调使模型的可解释性降低,并使得追踪行为是否来自微调或原始模型变得更加困难。

  • 计算资源:RAG 与编码器和数据库相关联,存在额外的成本(查找信息、嵌入数据、存储信息等)。这可能会增加延迟成本(你必须将检索时间添加到生成时间)。微调需要准备和整理高质量的数据集(获取某些数据集可能既昂贵又费时)。此外,微调与模型重新训练相关联的计算成本,但它提供了更低的延迟。此外,与微调相比,RAG 需要的技术专业知识更少。

  • 减少幻觉:RAG 本身对幻觉的倾向性较低,并允许追踪使用了哪些上下文。微调可以减少幻觉(但,通常,微调后的 LLM 仍然会表现出幻觉)。

  • 伦理和隐私问题:在 RAG 的情况下,我们必须小心如何保存存储在数据库中的信息。数据库必须受到潜在入侵的保护,并防止泄露。对于微调,重要的是要关注训练数据集,并防止其包含敏感数据。

RAG 是在需要一种能够适应实时数据或我们拥有大量未良好结构化的内部数据时的最佳系统。同样,当需要最小化幻觉并确保透明度至关重要时,RAG 也是首选。当我们需要模型发展特定技能或希望将模型与特定的写作风格或词汇表对齐时,微调是优先选择。

一些实际例子显示了在何种情况下最好选择微调或 RAG:

  • 摘要对于高度专业化的领域尤为重要。模型最好理解上下文更为关键,因此微调更为合适。

  • 问答是一个极其相关的任务,常用于不同领域(如关于文档、产品等问题)。在这种情况下,减少幻觉和透明度是关键方面,但定制化则不那么重要。因此,RAG 是更好的选择。

  • 代码生成是一个需要代码库动态的任务;同时,减少幻觉和错误也很重要。另一方面,我们需要模型尽可能适应任务。因此,RAG 和微调都将是有益的。

如最后一个例子所示,在某些情况下,微调和 RAG 都是有益的。这两个系统并不一定是对立的。我们可以对 LLM 和嵌入器都进行微调。因此,拥有一个结合了 RAG 和对 LLM(甚至 RAG 编码器)进行微调的系统将是有益的。针对我们数据领域特定任务的能力进行针对性微调可以带来更好的性能。这允许我们有一个动态的信息系统(我们在这里进行 RAG 更新),但同时也使 LLM 的风格适应该领域。LLM 也将更有能力理解和利用 RAG 提供的上下文。另一个微调模型有益的案例是当找到的数据具有特定格式(代码、表格、XML 或其他格式)时——我们就可以使用适应这些特定格式的 LLM(而不是一个天真的 LLM)。此外,我们可以通过利用提供的上下文来优化 LLM 以生成答案的任务。在这种情况下,LLM 可以被推动充分利用找到的上下文。

编码器也可以进行微调。使用特定数据集微调嵌入器可以增加模型对上下文的理解(记住,编码器是一个对数据有一定上下文理解的语模型)。这允许 LLM 更好地理解数据的特定领域细微差别,从而实现更好的上下文检索(与查询更相关的块)。当然,并非总是能够获得用于此任务的数据集。然而,存在一些方法,可以通过生成合成数据或使用大型 LLM 创建适合编码器微调的数据集。

与从头开始训练相比,微调嵌入器成本更低。今天,许多模型可供选择,例如 Sentence Transformer 之类的库简化了微调过程。这些模型已经被预先训练为嵌入器,但在微调过程中,我们希望更好地将它们适配到我们特定的数据类型或领域。通常,这种微调是通过使用与嵌入器训练相似的监督学习数据集来进行的(包含正例和反例)。

现在我们已经看到了主要组件,在下一节中,我们将组装系统。

使用 RAG 构建电影推荐代理

在前面的章节中,我们讨论了 RAG 是什么以及如何使用这个系统来减少幻觉或扩展模型知识。正如我们提到的,这个系统由以下组件组成:

  • 一个用于生成答案的 LLM

  • 将查询和文档转换为向量的编码器/检索器

  • 一个向量数据库,我们在这里保存我们的向量

在这个例子中,我们有一个电影及其描述的数据集,我们想要创建一个系统,通过提出一个自然语言问题,将根据我们提供的信息建议最合适的电影。我们的 LLM 对电影没有特定的知识,其参数化记忆不包含有关最新发布的任何信息。因此,RAG 是一个很好的系统来补充其知识。

  1. 第一步是获取一个块语料库。在获取了一组文档后,我们必须将其缩减为块。一个好的折衷方案是使用保留语义信息(无需使用 LLM)的文本分割器。在这种情况下,我们使用一个 1500 字符大小的块分割器。我们将其应用于我们的数据框的列:

    text_splitter = NLTKTextSplitter(chunk_size=1500)
    def split_overview(overview):
        if pd.isna(overview):
            return []
        return text_splitter.split_text(str(overview))
    df['chunks'] = df['text_column'].apply(split_overview)
    
  2. 接下来,我们需要将我们的块转换为向量。在这种情况下,我们使用all-MiniLM-L6-v2作为嵌入器。all-MiniLM-L6-v2是一个在嵌入质量和速度之间取得良好平衡的小型模型。实际上,该模型只有 2270 万个参数,这使得它非常快,是测试 RAG 管道的初始选择。

    在这个例子中,我们执行以下操作:

    • 加载模型(嵌入器)

    • 创建一个执行嵌入的函数

    • 执行各种向量的嵌入

      embedder = SentenceTransformer('all-MiniLM-L6-v2')
      def encode_chunk(chunk):
          if not isinstance(chunk, str) or chunk.strip() == "":
              return None
          return embedder.encode(chunk).tolist()
      chunked_df['embeddings'] = chunked_df['chunks'].apply(encode_chunk)
      
  3. 在这一点上,我们需要将我们创建的向量保存到数据库中。作为向量数据库的一个流行选择是 Chroma。在这种情况下,我们需要执行以下操作:

    • 启动 Chroma 客户端

    • 创建一个新的集合

    • 插入块

      chunked_df.dropna(subset=['embeddings'], inplace=True)
      client = chromadb.Client()
      collection = client.create_collection(name='movies')
      for idx, row in chunked_df.iterrows():
          collection.add(
              ids=[str(idx)],
              embeddings=[row['embeddings']],
              metadatas=[{
                  'original_title': row['original_title'],
                  'chunk': row['chunks']
              }]
          )
      

重要提示

注意,我们可以添加元数据(在这种情况下,电影的标题)。

我们现在只实现了我们之前描述的管道的第一部分。目前,我们有一个包含 RAG 向量的数据库。

图 5.21 – 向量数据库管道

图 5.21 – 向量数据库管道

现在,当查询到达时(在推理中),我们需要创建一个管道。在这种情况下,我们想要为查询创建一个向量,并在我们的向量数据库中搜索最相似的 k 个向量。这将返回文本给 LLM,然后生成对查询的答案。

  1. 尽管我们使用与找到块相同的嵌入器模型,但我们需要一个执行以下操作的功能:

    • 为查询创建一个向量

    • 找到最相似的文档

    • 返回关联文本

      def retrieve_documents(query, collection, top_k=5):
          query_embedding = embedder.encode(query).tolist()
          results = collection.query( query_embeddings=[query_embedding], n_results=top_k )
          chunks = []
          titles = []
          for document in results['metadatas'][0]:
              chunks.append(document['chunk'])
              titles.append(document['original_title'])
          return chunks, titles
      

    在这一点上,我们需要生成答案,因此我们需要一个 LLM。想法是向 LLM 提供清晰的指令,因此我们创建一个简单的提示来解释任务给模型。我们还向模型提供上下文和问题:

    tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1")
    model = AutoModelForCausalLM.from_pretrained(
        "mistralai/Mistral-7B-Instruct-v0.1",
        device_map='auto')
    text_generation_pipeline = pipeline(
        model=model,
        tokenizer=tokenizer,
        task="text-generation",
        return_full_text=True,
        max_new_tokens=800)
    def generate_answer(query, chunks, titles, text_generation_pipeline):
        context = "\n\n".join([f"Title: {title}\nChunk: {chunk}" for title, chunk in zip(titles, chunks)])
        prompt = f"""[INST]
        Instruction: You're an expert in movie suggestions. Your task is to analyze carefully the context and come up with an exhaustive answer to the following question:
        {query}
        Here is the context to help you:
        {context}
        [/INST]"""
        generated_text = text_generation_pipeline(prompt)[0]['generated_text']
        return generated_text
    

现在,我们可以测试它。我们可以向系统提问,看看它是否生成一个响应:

client = chromadb.Client()
collection = client.get_collection(name='movies')
query = "What are some good movies to watch on a rainy day?"
top_k = 5
chunks, titles = retrieve_documents(query, collection, top_k)
print(f"Retrieved Chunks: {chunks}")
print(f"Retrieved Titles: {titles}")
if chunks and titles:
    answer = generate_answer(query, chunks, titles, text_generation_pipeline)
    print(answer)
else:
    print("No relevant documents found to generate an answer.")

现在我们有一个完整的系统。这个原则适用于任何文档集合。

摘要

RAG 是 LLM 领域中增长最快的范式之一。消除幻觉是 LLM 和代理投入生产的最重要挑战之一,也是最具挑战性的约束之一。RAG 也是一个灵活的系统,与微调相比具有几个优点。正如我们所见,这个系统可以以最低的成本频繁更新,并且与不同类型的数据兼容。简单的 RAG 是基本系统,由三个主要组件组成:一个 LLM、一个嵌入器和向量数据库。

在下一章中,我们将看到这个系统是如何演变的。现在有许多新的附加组件,我们也将对其进行研究。尽管有 RAG,但有时模型仍然像忽略上下文一样产生幻觉。这就是为什么发展了复杂组件,我们将详细探讨。我们还将讨论参数记忆和上下文之间微妙的相互作用。

进一步阅读

第六章:信息检索和增强的高级 RAG 技术

在上一章中,我们讨论了 RAG 以及这种范式如何演变以解决 LLMs 的一些不足。然而,即使是简单的 RAG(这种范式的原始形式)也并非没有其挑战和问题。简单的 RAG 由几个简单的组件组成:一个嵌入器、一个用于检索的向量数据库和一个用于生成的 LLM。正如前一章所述,简单的 RAG 涉及将文本集合嵌入到数据库中;一旦用户查询到达,就会搜索与查询相关的文本块,并将其提供给 LLM 以生成响应。这些组件使我们能够有效地响应用户查询;但正如我们将看到的,我们可以添加额外的组件来改进系统。

在本章中,我们将看到在高级 RAG 中,我们可以修改或改进管道中的各个步骤(数据摄入、索引、检索和生成)。这解决了简单 RAG 的一些问题,并使我们能够更好地控制整个过程。我们稍后将看到,对更多灵活性的需求导致了进一步的进步(模块化 RAG)。我们还将讨论 RAG 的重要方面,特别是在系统(RAG 基础产品)被生产时。例如,我们将讨论在数据量或用户数量很大时的挑战。此外,由于这些系统可能包含敏感数据,我们将讨论鲁棒性和隐私。最后,尽管 RAG 是当今流行的系统,但它仍然相对较新。因此,仍然存在一些未解决的问题和令人兴奋的前景。

在本章中,我们将讨论以下主题:

  • 讨论简单的 RAG 问题

  • 探索高级 RAG 管道

  • 模块化 RAG 和与其他系统的集成

  • 实现高级 RAG 管道

  • 理解 RAG 的可扩展性和性能

  • 开放性问题

技术要求

本章中的大部分代码可以在 CPU 上运行,但最好在 GPU 上运行。代码是用 PyTorch 编写的,大部分使用标准库(PyTorch、Hugging Face Transformers、LangChain、chromadb、sentence-transformer、faiss-cpu等)。

本章的代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr6。

讨论简单的 RAG 问题

在上一章中,我们介绍了 RAG 的基本版本(称为简单 RAG)。尽管 RAG 的基本版本在解决 LLMs 的一些最紧迫问题方面已经取得了长足的进步,但仍然存在一些问题。特别是对于工业应用(以及医疗、法律和金融),简单的 RAG 是不够的,我们需要一个更复杂的管道。现在,我们将探讨与简单 RAG 相关的问题,每个问题都与管道中的特定步骤(查询处理、检索和生成)相关。

图 6.1 – 简要概述了简单的 RAG 问题和识别管道中可能出现问题的不同步骤

图 6.1 – 简要概述了简单的 RAG 问题以及识别管道中可能出现问题的不同步骤

让我们详细讨论这些问题:

  • 检索挑战:检索阶段在精确度(检索到的片段不匹配)和召回率(找到所有相关片段)方面存在困难。此外,知识库可能过时。这可能导致幻觉,或者根据使用的提示,可能得到“对不起,我不知道答案”或“上下文不允许回答查询”之类的响应。这也可以从数据库索引不良或文档类型不同(PDF、HTML、文本等)且处理不当(例如,对所有文件类型进行分块)中得出。

  • 遗漏顶级文档:对于回答查询至关重要的文档可能不在列表的顶部。通过选择前 k 个文档,我们可能会选择不那么相关(或不含答案)的顶级片段,而没有返回真正相关的片段给 LLM。嵌入模型的语义表示能力可能较弱(即,我们选择了一个无效的模型,因为它太小或不适合我们文档的领域)。

  • 上下文中没有相关信息:找到了包含答案的文档,但太多以至于无法适应 LLM 的上下文。例如,响应可能需要几个片段,而这些片段对于模型的上下文长度来说太多了。

  • 提取失败:可能已经将正确的上下文返回给 LLM,但它可能无法提取正确的答案。通常,这发生在上下文中噪声过多或信息冲突的情况下。即使提示(上下文)中包含答案,模型也可能产生幻觉(上下文幻觉)。

  • 答案格式错误:查询可能有额外的具体要求。例如,我们可能希望 LLM 生成项目符号或以表格形式报告信息。LLM 可能会忽略这些信息。

  • 不正确的具体性:生成的答案不够具体或过于具体,不符合用户的需求。这通常与系统的设计及其目的有关。我们的 RAG 可能是为设计给学生的产品的一部分,必须就某个主题给出清晰和全面的答案。另一方面,模型可能回答得过于模糊或过于技术化,不适合学生。通常,当查询(或指令)不够清晰时,会出现这个问题。

  • 增强障碍或信息冗余:我们的数据库可能包含来自不同语料库的信息,许多文档可能包含冗余信息或具有不同的风格和语气。LLM 随后可能会生成重复内容和/或创造幻觉。此外,由于模型未能整合来自各个片段的信息,答案可能质量不高。

  • 不完整的答案:这些答案并不错误,但是不完整的(这可能是因为没有找到所有必要的信息或 LLM 在处理上下文时的错误)。有时,这也可能是查询过于复杂的问题(“总结 A、B 和 C 项”),因此修改查询可能更好。

  • 缺乏灵活性:这是当系统不够灵活时;它目前不允许高效更新,并且我们不能整合来自用户、过去交互等的反馈。系统不允许我们处理我们语料库中丰富的某些文件(例如,我们的系统不允许 Excel 文件)。

  • 可扩展性和整体性能:在这种情况下,我们的系统可能太慢,无法进行嵌入、生成响应等。或者,我们无法每秒处理多个文档的嵌入,或者我们遇到特定于我们的产品或领域的问题。系统安全性是一个痛点,尤其是如果我们有敏感数据的话。

现在我们已经了解了朴素 RAG 的问题,让我们来看看高级 RAG 是如何帮助我们解决这些问题的。

探索高级 RAG 管道

高级 RAG 引入了一系列特定的改进,试图解决朴素 RAG 中提出的问题。换句话说,高级 RAG 通过修改 RAG 的各个组件来尝试优化 RAG 范式。这些各种修改发生在 RAG 的不同步骤中:检索前和检索后。

在检索前过程中,目的是优化索引和查询。例如,添加元数据可以提供更细粒度的搜索,并且我们向 LLM 提供更多内容以生成文本。元数据可以简洁地包含信息,否则这些信息将分散在整个文档中。

在朴素 RAG 中,我们将文档分成不同的片段,并为每个文档找到相关的片段。这种方法有两个局限性:

  • 当我们拥有许多文档时,它会影响延迟时间和性能

  • 当文档很大时,我们可能无法轻松找到相关的片段

在朴素 RAG 中,只有一个级别(即使它们来自不同的文档,所有片段都是等效的)。然而,一般来说,对于许多语料库,存在层次结构,利用它可能是有益的。

为了解决这些限制,高级 RAG 引入了几个增强功能,旨在提高检索和生成的效率。在接下来的小节中,我们将探讨一些技术

层次化索引

对于由多个章节组成的文档,我们首先可以找到感兴趣的章节,然后从那里搜索感兴趣的各个部分。由于章节可能相当大(噪声丰富),嵌入可能无法最好地代表它们的上下文意义。解决方案是使用摘要和元数据。在层次索引中,你在每个层次级别创建摘要(这可以被认为是摘要)。在第一级,我们有只突出显示大文档段中关键点的摘要。在较低级别,粒度将增加,这些摘要将越来越接近仅包含相关数据部分。接下来,我们将对这些摘要进行嵌入。在推理时间,我们将计算与这些摘要嵌入的相似度。当然,这意味着我们可能需要手动编写摘要,或者使用 LLM 进行摘要。然后,使用相关的元数据,我们可以找到与摘要匹配的块,并将其提供给模型。

图 6.2 – 层次索引

图 6.2 – 层次索引

如前图所示,语料库被分为文档;然后我们获取每个文档的摘要并将其嵌入(在简单的 RAG 中,我们是将文档分割成块并嵌入块)。在下一步中,我们将嵌入文档较低层次级别的摘要(章节、部分、标题和副标题),直到达到块级别。在推理时间,对摘要进行相似度搜索以检索我们感兴趣的块。

这种方法有一些变体。为了获得更多控制,我们可以为每种文件类型(HTML、PDF 和 GitHub 仓库)选择一个分割方法。这样,我们可以使摘要数据类型特定,并嵌入摘要,这相当于一种文本归一化。

当我们拥有的文档对于我们的 LLM 摘要器来说太长时,我们可以使用映射和归约,首先对文档的各个部分进行摘要,然后整理这些摘要,得到一个单一的摘要。如果文档过于百科全书式(即涉及太多主题),存在语义噪声影响检索的风险。为了解决这个问题,我们可以为每个文档提供多个摘要(例如,每 10K 个标记或每 10 页文档一个摘要)。

层次索引提高了对文档的上下文理解(因为它尊重其层次结构并捕获各个部分之间的关系,如章节、标题和副标题)。这种方法允许在查找结果时具有更高的准确性,并且它们更加相关。另一方面,这种方法在检索前阶段和推理阶段都有成本。层次太多,你可能会面临组合爆炸的风险,即由于可能组合的指数级增加而导致的复杂性的快速增长,以及巨大的延迟成本。

图 6.3 – 层次索引变化

图 6.3 – 层次索引变化

在前面的图中,我们可以看到这些层次索引的变化:

  • A: 对每种文档类型进行不同的处理,以更好地表示其结构

  • B: 映射和归约处理过长的文档(创建中间摘要,然后用于创建最终文档摘要)

  • C: 当文档讨论太多主题时,每个文档的多摘要

假设性问题与 HyDE

对简单的 RAG 管道的另一种修改是尝试使块和可能的问题在语义上更加相似。通过了解我们的用户是谁,我们可以想象他们将从我们的系统中获得什么样的用途(对于一个聊天机器人,大多数查询将是问题,因此我们可以调整系统以适应这些类型的查询)。假设性问题是一种策略,其中我们使用一个 LLM 为每个块生成一个(或多个)假设性问题。然后,将这些假设性问题转换为向量(嵌入),并在有用户查询时使用这些向量进行相似性搜索。当然,一旦我们确定了与我们的实际查询最相似的假设性问题,我们就找到块(多亏了元数据)并将它们提供给模型。我们可以为每个块生成单个查询或多个查询(这增加了准确性以及计算成本)。在这种情况下,我们不是使用块的向量表示(我们不进行块的嵌入,而是假设性问题)。此外,我们不一定需要保存假设性问题,只需它们的向量(重要的是我们能够将它们映射回块)。

假设文档嵌入(HyDE)则试图将用户答案转换为更好地匹配块。给定一个查询,我们为它创建假设性答案。之后,我们对这些生成的答案进行嵌入,并执行相似性搜索以找到感兴趣的块。这些生成的答案应该与用户的查询在语义上最为相似,使我们能够找到更好的块。在某些变体中,我们创建五个不同的生成答案,并在进行相似性搜索之前对这些答案的嵌入向量进行平均。这种方法可以帮助我们在检索步骤中召回率低时,或者当文档(或查询)来自与检索域不同的特定领域时。事实上,嵌入模型在它们未见过的知识域中泛化得不好。一个有趣的注释是,当 LLM 生成这些假设性答案时,它不知道确切的答案(这甚至不是这种方法的目的),但它能够捕捉到问题中的相关模式。然后,我们可以使用这些捕获的模式来检索块。

让我们详细地看看两种方法之间的差异。在假设问题方法中,我们生成假设问题,并使用这些假设问题的嵌入来找到感兴趣的片段。在 HyDE 中,我们生成针对查询的假设答案,然后使用这些答案的嵌入来找到感兴趣的片段。

图 6.4 – 假设问题和 HyDE 方法

图 6.4 – 假设问题和 HyDE 方法

然后,我们可以详细地比较两种方法之间的差异,假设我们有一个假设用户问题(“使用对乙酰氨基酚的潜在副作用是什么?”):

  • 检索前阶段:在此阶段,我们必须创建我们的药物嵌入数据库。我们将文档(药物安全报告的部分)减少为片段。在假设问题方法中,对于每个片段,使用 LLM 生成假设问题(例如,“这种药物的副作用是什么?”或“是否有提到任何不良反应?”)。然后,将这些假设问题嵌入到向量空间中(这些问题的向量数据库)。在此阶段,HyDE 等同于经典的 RAG;没有进行任何变异。

  • 查询阶段:在假设问题方法中,当用户提交查询时,它会被嵌入并与嵌入的假设问题进行匹配。系统寻找与用户问题最相似的假设问题(在这种情况下,可能是“这种药物的副作用是什么?”)。在此阶段,识别出生成这些假设问题的片段(我们使用元数据)。这些片段被提供在上下文中进行生成。在 HyDE 中,当用户查询到达时,LLM 生成假设答案(例如,“对乙酰氨基酚可能引起恶心、肝损伤和皮疹等副作用”或“潜在的不良反应包括头晕和胃肠道不适”)。

    注意,这些答案是通过不检索的 LLM 知识生成的。在此阶段,我们对这些假设答案进行嵌入(我们使用嵌入模型),然后对查询进行嵌入,并尝试将其与嵌入的假设答案匹配。例如,“对乙酰氨基酚可能引起恶心、肝损伤和皮疹等副作用”是与用户查询最接近的一个。然后我们搜索与这些假设答案最接近的片段,并将这些片段提供给 LLM 生成上下文。

上下文丰富

另一种技术是上下文丰富,其中我们找到更小的段(更细粒度以获得更好的搜索质量),然后添加周围上下文。句子窗口检索是其中一种技术,其中文档中的每个句子都单独嵌入(嵌入的文本单元更小,因此更细粒度)。这使我们能够在寻找答案时具有更高的精确度,尽管我们可能会失去 LLM 推理的上下文(因此生成效果较差)。为了解决这个问题,我们扩展了上下文窗口。在找到句子 x 后,我们取文档中围绕它的 k 个句子(在文档中位于我们的句子 x 之前和之后的句子)。

父文档检索器 是一种类似的技术,试图在搜索小段和提供大段上下文之间找到平衡。文档被分成小段子文档,但我们保留了它们父文档的层次结构。在这种情况下,我们直接针对查询的具体内容进行小段的嵌入(确保大段的相关性)。然后我们找到较大的父文档(找到的段所属的文档)并将它们提供给 LLM 进行生成(更多上下文信息和深度)。为了避免检索过多的父文档,一旦找到前 k 个段,如果超过 n 个段属于一个父文档,我们将此文档添加到 LLM 上下文中。

这些方法在以下图中展示:

  1. 一旦找到一个段,我们就使用前一个和后一个段来扩展选择。

  2. 我们对小段文本进行嵌入并找到前 k 个段;如果大部分段(大于参数 n)都来自一个文档,我们将该文档作为上下文提供给 LLM。

图 6.5 – 上下文丰富方法

图 6.5 – 上下文丰富方法

查询转换

查询转换 是一系列利用 LLM 来提高检索的技术。如果一个查询过于复杂,它可以被分解成一系列子查询。实际上,我们可能找不到一个直接响应查询的段,但更容易找到响应每个子查询的段(例如,“电报和电话的发明者是谁?”最好分解成两个独立的查询)。回退提示 使用 LLM 生成一个更通用的查询,以匹配高级上下文。这源于当人类面对困难任务时,他们会退一步进行抽象以到达高级原则的想法。在这种情况下,我们使用这个高级查询的嵌入和用户的查询,并将这两个找到的上下文都提供给 LLM 进行生成。查询重写,另一方面,使用 LLM 重新表述初始查询以简化检索。

图 6.6 – 查询转换的三个示例

图 6.6 – 查询转换的三个示例

查询扩展是一种类似于查询重写的技巧。其背后的理念是,向查询中添加术语可以使它找到与查询没有词汇重叠的相关文档(从而提高检索召回率)。同样,我们使用 LLM 来修改查询。有两种主要可能性:

  • 请求一个 LLM(大型语言模型)对查询生成答案,之后将生成的答案和查询嵌入并用于检索。

  • 生成几个与原始查询相似的查询(通常是一个前缀数字n)。然后,将这n个查询向量化并用于搜索。

这种方法通常可以提高检索效果,因为它有助于消除查询歧义并找到否则可能找不到的文档;它还有助于系统更好地编制查询。然而,另一方面,它也可能导致找到不相关的文档,因此结合后处理技术来查找文档是值得的。

关键词搜索和混合搜索

提高搜索的另一种方法是不仅要关注上下文信息,还要关注关键词。基于关键词的搜索是通过某些特定关键词的精确匹配来进行的搜索。这种搜索对特定术语(如产品或公司名称或特定行业术语)有益。然而,它对拼写错误和同义词敏感,并且无法捕捉上下文。向量或语义搜索则相反,它找到查询的语义含义,但找不到精确的术语或关键词(这在某些查询中有时是必不可少的,尤其是在某些领域,如市场营销)。混合搜索通过结合关键词搜索和向量搜索的模型,取两者之长。

最常用的关键词搜索模型是 BM25(我们在上一章中讨论过),它生成稀疏嵌入。BM25 然后允许我们识别包含查询中特定术语的文档。因此,我们创建了两个嵌入:一个使用 BM25 的稀疏嵌入和一个使用 transformer 的密集嵌入。为了选择最佳片段,你通常试图平衡不同类型搜索的影响。最终得分是两个得分的加权组合(你使用一个 alpha 超参数):

<mrow><mrow><msub><mrow><mi>s</mi><mi>c</mi><mi>o</mi><mi>r</mi><mi>e</mi></mrow><mrow><mi>h</mi><mi>y</mi><mi>b</mi><mi>r</mi><mi>r</mi><mi>i</mi><mi>d</mi></mrow></msub><mo>=</mo><mfenced close=")" open="("><mrow><mn>1</mn><mo>−</mo><mi mathvariant="normal">α</mi></mrow></mfenced><mo>∙</mo><msub><mrow><mi>s</mi><mi>c</mi><mi>o</mi><mi>r</mi><mi>e</mi></mrow><mrow><mi>s</mi><mi>p</mi><mi>a</mi><mi>r</mi><mi>s</mi><mi>e</mi></mrow></msub><mo>+</mo><mi mathvariant="normal">α</mi><mo>∙</mo><msub><mrow><mi>s</mi><mi>c</mi><mi>o</mi><mi>r</mi><mi>e</mi></mrow><mrow><mi>d</mi><mi>e</mi><mi>n</mi><mi>s</mi><mi>e</mi></mrow></msub></mrow></mrow>

α 的值介于 0 和 1 之间(0 表示纯向量搜索,而 1 表示仅关键词搜索)。通常,α 的值是 0.4 或 0.5(其他文章甚至建议 0.3)。

作为实际例子,我们可以想象一个拥有庞大产品目录的电子商务平台,包含数百万种商品,涵盖电子、时尚和家用电器等类别。用户会使用不同类型的查询来搜索产品,以下是一些可能的查询类型:

  • 特定术语,如品牌或产品名称(例如,“iPhone 16”)

  • 一般描述(例如,“中等价位的具有良好摄像头的手机”)

  • 包含混合元素的查询(例如,“价格低于 500 美元的 iPhone”)

纯关键词搜索(例如 BM25 算法)在处理模糊或纯粹描述性的描述时会遇到困难,而基于向量的语义搜索可能会错过产品的精确匹配。混合搜索结合了两者之长。BM25 优先考虑精确匹配,如“iPhone”的匹配,使我们能够通过关键词找到特定项目。语义搜索允许我们捕捉到“具有良好摄像头的手机”之类的短语的语义含义。混合搜索是解决前述三种情况的一个很好的解决方案。

查询路由

到目前为止,我们假设一旦查询到达,就会在向量数据库中进行搜索。实际上,我们可能希望以不同的方式或控制系统内的流程进行搜索。例如,系统应该能够与不同类型的数据库(向量、SQL 和专有数据库)、不同来源或不同类型的模态(图像、文本和声音)进行交互。因此,一些查询可能不需要使用 RAG 进行搜索;模型的参数化内存可能就足够了(我们将在开放问题和未来展望部分进行更深入的讨论)。查询路由因此允许控制系统如何响应查询。你可以想象它是一系列 if/else 条件,尽管它不是硬编码的,我们有一个路由器(通常是一个 LLM),每当查询到达时都会做出决定。显然,这意味着我们有一个非确定性的系统,它并不总是能做出正确的决定,尽管它可以对性能产生重大积极影响。

路由器可以是一组逻辑规则或一个神经网络模型。以下是一些路由器的选项:

  • 逻辑路由器:一组逻辑规则,可以是 if/else 语句(例如,如果查询是图像,则搜索图像数据库;否则,搜索文本数据库)。逻辑路由器不理解查询,但它们非常快且确定。

  • 关键词路由器:一种稍微复杂一些的替代方案,我们尝试通过在查询和选项列表之间匹配关键词来选择路由。这种搜索可以使用稀疏编码器、专用包甚至 LLM 来完成。

  • 零样本分类路由器:零样本分类是一个任务,其中要求一个大型语言模型(LLM)对一组未指定和训练过的标签进行分类。每个查询都提交给一个 LLM,它必须从列表中选择一个路由标签。

  • LLM 函数调用路由器:不同的路由被描述为函数(具有特定的描述),模型必须通过选择函数(在此方法中,我们利用其决策能力)来决定将查询导向何处。

  • 语义路由器:在此方法中,我们使用语义搜索来决定最佳路由。简而言之,我们有一个示例查询列表及其相关路由。然后,这些查询被嵌入并保存为数据库中的向量。当查询到达时,我们对我们数据库中的其他查询进行相似度搜索。然后,我们选择与最佳相似度匹配的查询相关的选项。

图 6.7 – 查询路由

图 6.7 – 查询路由

一旦我们找到了上下文,我们需要将其与查询整合,并提供给 LLM 进行生成。有几种策略可以改进这个过程,通常称为检索后策略。在向量搜索之后,检索返回前k个文档(一个预先确定的任意截止值)。这可能导致相关信息丢失。最简单的解决方案是增加前k个块的价值。显然,我们无法返回所有检索到的块,因为它们不会适合模型的上下文长度,而且 LLM 在处理所有这些信息时也会遇到问题(有效利用长上下文长度)。

我们可以想象一家公司提供不同领域的不同服务,例如银行、保险和金融。客户通过与聊天机器人互动来寻求银行服务(账户详情、交易等)、保险服务(保单详情、索赔等)和金融服务(建议、投资等)的协助。每个领域都有其独特性。由于法规和隐私问题,我们希望防止聊天机器人搜索其他服务的客户详情。此外,对每个查询搜索所有数据库既不高效,还会导致更多延迟和无关的结果。

重排序

解决这一困境的一个建议方案是最大化文档检索(增加前k个检索到的结果,从而提高检索召回率指标),同时最大化 LLM 的召回率(通过最小化提供给 LLM 的文档数量)。这种策略被称为重排序。重排序包括两个步骤:

  1. 首先,我们进行经典检索并找到大量块。

  2. 接下来,我们使用重排序器(第二个模型)重新排序块,然后选择前k个块提供给 LLM。

重新排序器提高了返回给 LLM 的块的质量,并减少了系统中的幻觉。此外,重新排序考虑了与查询相关的对比信息,然后考虑与查询相关的上下文中的块。有几种类型的重新排序器,每种都有其自身的局限性和优点:

  • 交叉编码器:这些是变换器(如 BGE),它们接受两个文本序列(查询和各个块逐个)作为输入,并返回 0 到 1 之间的相似度。

  • 多向量重新排序器:这些仍然是变换器(如 ColBERT)并且比交叉编码器(两个序列之间的交互是后期阶段)需要的计算更少。原理类似;给定两个序列,它们返回 0 到 1 之间的相似度。有改进版本,具有较长的上下文长度,如 jina-colbert-v1-en。

  • 用于重新排序的 LLM:LLM 也可以用作重新排序器。使用几种策略来提高 LLM 的排名能力:

    • 点 wise 方法用于计算查询和单个文档的相关性(也称为零样本文档重新排序)。

    • 成对方法包括向 LLM 提供查询和两个文档,并要求它选择哪个更相关。

    • 按列表方法,另一方面,建议向 LLM(大型语言模型)提供一个查询和一个文档列表,并指示它生成一个按排名排序的输出列表。通常使用 GPT 等模型,但存在高计算或经济成本的风险。

  • 微调的 LLM:这是一类专门用于排名任务的模型。尽管 LLM 是通用模型,但它们没有针对排名的特定训练,因此无法准确衡量查询-文档的相关性。微调使它们能够提高其能力。通常,使用两种类型的模型:编码器-解码器变换器(RankT5)或仅解码器变换器(例如 Llama 和 GPT 的衍生品)。

所有这些方法都会对性能(检索质量)和成本(计算成本、系统延迟和潜在的系统成本)产生影响。一般来说,多向量是那些计算成本较低且性能离散的。基于 LLM 的方法可能具有最佳性能,但计算成本很高。一般来说,重新排序对系统有积极影响,这也是为什么它经常是管道的一部分。

图 6.8 – 重新排序方法。用红色突出显示的块是与查询相关的块

图 6.8 – 重新排序方法。用红色突出显示的块是与查询相关的块

另外,还有其他后处理技术。例如,如果达到的相似度低于某个分数阈值,如果它们不包含某些关键词,如果与块关联的元数据中不存在某个值,如果块比某个日期旧,以及许多其他可能性。另一个策略是,一旦我们找到了块,从嵌入向量开始,我们进行k 近邻(kNN)研究。换句话说,我们在那些找到的块在潜在空间中的邻居中添加其他块(这种策略可以在重新排序之前或之后进行)。

此外,一旦选择了要提供给 LLM 的上下文中的块,我们就可以改变它们的顺序。如图所示,2023 年发表的一项研究表明,对于 LLM 来说,将重要信息放在输入上下文长度的开头或末尾可以获得最佳性能(如果信息位于上下文长度的中间,性能会下降,尤其是如果它非常长):

图 6.9 – 改变相关信息的位置会影响 LLM 的性能 (https://arxiv.org/abs/2307.03172)

图 6.9 – 改变相关信息的位置会影响 LLM 的性能 (arxiv.org/abs/2307.03172)

正因如此,有人提出了重新排序块的建议。它们可以按照相关性排序,也可以按照交替模式(偶数索引的块放在列表开头,奇数索引的块放在列表末尾)。交替模式特别适用于使用宽顶 k 块时,这样最相关的块就被放在了开头和末尾(而不那么相关的块则位于上下文长度的中间)。

你可以注意到重新排序提高了系统的性能:

图 6.10 – 重新排序提高了问答性能 (https://arxiv.org/pdf/2409.07691)

图 6.10 – 重新排序提高了问答性能 (arxiv.org/pdf/2409.07691)

除了重新排序之外,还可以在检索阶段之后应用几种补充技术来进一步细化传递给 LLM 的信息。这包括提高引用准确性的方法、管理聊天历史、压缩上下文和优化提示公式。让我们看看其中的一些。

参考文献引用并不是系统改进的技术,但它作为 RAG 系统的一个组成部分被高度推荐。特别是如果我们使用不同的来源来组成我们的查询响应,跟踪使用了哪些来源(例如,LLM 使用的文档)是很好的。我们可以简单地保护用于生成的来源(哪些文档的块对应)。另一种可能性是在 LLM 的提示中提及使用的来源。一种更复杂的技术是模糊引用查询引擎。模糊匹配是对生成的响应与找到的块进行字符串搜索以匹配(一种基于将块中的单词分为 n-gram 然后进行 TF-IDF 的技术)。

ChatEngine是 RAG 的另一个扩展。对模型进行微调是复杂的,但与此同时,我们希望 LLM 记住与用户的先前交互。RAG 使得这样做变得容易,因此我们可以保存与用户的先前对话。一种简单的方法是将之前的聊天包括在提示中。或者,我们可以对聊天进行嵌入并找到亮点。另一种技术是尝试捕捉用户对话的上下文(聊天逻辑)。由于讨论可能贯穿几条消息,为了避免可能超过上下文长度的提示,一种解决方案是提示压缩。我们通过减少与用户的先前交互来缩短提示长度。

通常来说,上下文压缩是一个有助于 LLM 在生成过程中使用的概念。它还能节省计算(或经济,如果通过 API 使用模型)资源。一旦找到文档,我们可以压缩上下文,目的是只保留相关信息。实际上,上下文通常也包含与查询无关的信息,甚至重复信息。此外,句子中的大多数单词都可以直接从上下文中预测出来,因此不需要在生成过程中提供给 LLM。有几种策略可以减少提供给 LLM 的提示:

  • 上下文过滤:在信息理论中,低熵的标记容易被预测,因此包含冗余信息(向 LLM 提供较少的相关信息,对其理解上下文的影响很小)。因此,我们使用一个 LLM 为每个词汇单元分配一个信息值(它期望在上下文中看到该标记或句子的程度)。我们按降序进行排名,只保留位于前 p 百分位的标记(我们事先决定,或者它可以依赖于上下文)。

  • LongLLMLingua:这是基于信息熵的另一种方法,使用上下文和查询(问题感知)中的信息。该方法通过动态压缩和重新排序文档来提高生成效率。

  • 自动压缩器:这使用了一种对系统和摘要向量的微调。其背后的想法是,长文本可以被总结成一个小的向量表示(摘要向量)。这些向量可以用作软提示,为模型提供上下文。这个过程依赖于在提示中引入可训练的标记的同时保持 LLM 的权重冻结。这些标记在训练期间学习,使得系统可以在不修改模型核心参数的情况下进行端到端优化。在生成过程中,这些向量被连接起来,模型随后变得具有上下文意识。已经训练好的模型如下:

图 6.11 – A) 上下文压缩和过滤。B) 自动压缩器。(改编自 https://arxiv.org/abs/2305.14788)

图 6.11 – A) 上下文压缩和过滤。B) 自动压缩器。(改编自arxiv.org/abs/2305.14788)

提示工程是提高生成的另一种解决方案。一些建议适用于与任何 LLM 的交互。因此,提供清晰(“使用上下文回复”)和不模糊(“如果答案不在上下文中,写我不知道”)的指令原则适用于 RAG。然而,可能存在针对设计我们系统最佳提示的具体方向或甚至示例。其他指令可能特定于我们想要的输出方式(例如,作为列表、HTML 等)。还有用于创建遵循特定格式的 RAG 提示的库。

响应优化

在进行最终响应之前,管道中的最后一步是改进用户的响应。一种策略是响应合成器。基本策略是将提示、上下文和查询连接起来,并将其提供给 LLM 进行生成。更复杂的策略涉及 LLM 的更多调用。对此想法有几种替代方案:

  • 一次使用一个片段迭代地细化响应。将之前的响应和随后的片段发送到模型中,以新的信息改进响应。

  • 使用不同的片段生成几个响应,然后将它们全部连接起来,生成一个总结响应。

  • 层次化摘要从为每个不同上下文生成的响应开始,递归地组合它们,直到我们得到单个响应。虽然这种方法提高了摘要和生成答案的质量,但它需要显著更多的 LLM 调用,因此在计算资源和财务费用方面都变得昂贵。

一个有趣的发展是使用 RAG 作为智能体系统组件的可能性。正如我们在*第四章中介绍的那样,RAG 可以作为系统的记忆。RAG 可以与智能体**结合。一个大型语言模型(LLM)能够进行推理,可以与 RAG 合并,并在查询需要额外步骤时调用工具或连接到网站。智能体还可以处理不同的组件(检索聊天历史、执行查询路由、连接到 API 和执行代码)。一个复杂的 RAG 流程可以包含几个不适合每个情况的组件,而 LLM 可以决定使用哪些最佳组件。

图 6.12 – 高级 RAG 流程中的不同元素

图 6.12 – 高级 RAG 流程中的不同元素

到目前为止,我们假设流程应该只执行一次。标准做法是我们先进行检索,然后生成。然而,对于需要多步推理的复杂问题,这种方法可能是不够的。在这种情况下有三种可能性:

  • 迭代检索:在这种情况下,检索会进行多次。给定一个查询,我们进行检索,生成结果,然后由 LLM 进行判断。根据判断,我们重复这个过程,直到 n 次。这个过程提高了每次迭代后答案的鲁棒性,但也可能导致无关信息的积累。

  • 递归检索:这个系统是为了增加搜索结果的深度和相关性而开发的。它与之前的一个类似,但在每次迭代中,查询会根据之前的搜索结果进行细化。目的是通过利用反馈循环来找到最相关的信息。许多这些方法利用思维链(CoT)来指导检索过程。在这种情况下,系统将查询分解成一系列必须解决的中间步骤。当查询不是特别清晰或所需信息高度专业或需要仔细考虑细微差别时,这种方法是有利的。

  • 自适应检索:在这种情况下,LLM 主动决定何时搜索以及检索的内容是否最优。LLM 不仅判断检索步骤,还判断自己的操作。LLM 可以决定何时响应、何时搜索或是否需要额外的工具。这种方法不仅用于在 RAG 上搜索时,也用于进行网络搜索。Flare(一种 RAG 的自适应方法)在生成过程中分析置信度,并在置信度低于某个阈值时做出决定。另一方面,Self-RAG 引入了反思令牌来监控过程并强制 LLM 进行反思。

图 6.13 – RAG 流程的增强 (https://arxiv.org/pdf/2312.10997)

图 6.13 – RAG 管道的增强 (arxiv.org/pdf/2312.10997)

为了更好地理解高级 RAG 技术如何解决已知的限制,表 6.1展示了关键问题与最近研究中提出的最有效解决方案之间的映射。

需要解决的问题 解决方案
朴素 RAG 的问题:在许多或大型文档中延迟和性能下降 使用分层索引:总结大块,创建多级嵌入,使用元数据,并实现长文档的 map-reduce 或多主题的多摘要等变体。
当语料库包含固有结构时,扁平层次结构限制了相关性 应用分层索引:尊重文档的结构(章节、标题和副标题),并根据分层摘要和嵌入检索上下文。
低检索准确率和特定领域的泛化挑战 为每个块生成和嵌入假设问题(假设 Qs)。使用 HyDE:生成与查询语义匹配的假设答案,嵌入它们,并检索相关块。
在细粒度分块中丢失上下文 使用上下文丰富:使用句子窗口扩展检索到的块周围的上下文,或检索父文档以扩展上下文。
从初始检索中产生的复杂查询和低召回率 应用查询转换:将复杂查询分解为子查询,使用回退提示或查询扩展。嵌入转换后的查询以改进检索。
特定术语或关键词的上下文不匹配 使用混合搜索:结合基于关键词的(例如,BM25)和基于向量的检索,使用加权评分。
管理多种查询类型时的低效 实现查询路由:使用逻辑规则、基于关键词或语义分类器、零样本模型或基于 LLM 的路由器将查询定向到适当的后端。
由于任意的 top-k 截止值而丢失相关块 应用重新排序:使用交叉编码器、多向量重新排序器或基于 LLM 的(点对点、成对或列表)重新排序来重新排序检索到的块。
在 LLM 上下文中丢失信息或效率 使用上下文压缩:过滤低熵标记,动态压缩或重新排序块(例如,LongLLMLingua),或应用摘要向量和自动压缩器。
低效的响应生成 优化响应:使用迭代细化、分层摘要或多步响应合成。提高提示质量和特异性。
对话系统中的内存限制 使用 ChatEngine 技术:保存并嵌入过去的对话,压缩用户对话,并将聊天历史与当前查询合并。
需要复杂推理或动态查询适应 采用自适应和多步骤检索:使用递归、迭代方法,并带有反馈循环和自我反思(例如,Flare,Self-RAG)。
生成响应中缺乏源追踪 包含引用:使用模糊引用匹配、元数据标记或在提示中嵌入源引用。
根据查询复杂性或模态进行管道定制的需求 增强 RAG 管道:与推理、工具使用和决策的代理结合。对于复杂查询,应用自适应和递归检索循环。

表 6.1 – RAG 中的问题和解决方案

模块化 RAG 及其与其他系统的集成

模块化 RAG 是一个进一步的发展;它可以被视为高级 RAG 的扩展,但更侧重于适应性和多功能性。在这种情况下,模块化系统意味着它具有可以单独使用或并行使用的独立组件。

管道本身经过重新设计,交替进行搜索和生成。一般来说,模块化 RAG 涉及优化系统性能并适应不同任务。模块化 RAG 引入了专门化的模块来实现这一点。以下是一些包含的模块示例:

  • 搜索模块:此模块负责查找关于查询的相关信息。它允许通过搜索引擎、数据库和知识图谱(KGs)进行搜索。它还可以使用复杂的搜索算法、机器学习并执行代码。

  • 记忆模块:此模块用于在搜索过程中存储相关信息。此外,系统可以检索之前搜索过的上下文。

  • 路由模块:此模块试图确定查询的最佳路径,它可以在不同的数据库中搜索不同的信息或分解查询。

  • 生成模块:不同的查询可能需要不同类型的生成,例如摘要、释义和上下文扩展。此模块的重点是提高输出质量和相关性。

  • 任务自适应模块:此模块允许系统动态适应请求的任务。这样,系统可以动态调整检索、处理和生成。

  • 验证模块:此模块评估检索到的响应和上下文。系统可以识别错误、偏见和不一致性。这个过程变得迭代,系统可以改进其响应。

图 6.14 – RAG 的三个不同范式 (https://arxiv.org/pdf/2312.10997)

图 6.14 – RAG 的三个不同范式 (arxiv.org/pdf/2312.10997)

模块化 RAG 具有适应性优势,因为这些模块可以根据需要替换或重新配置。不同模块之间的流程可以精细调整,从而提供额外的灵活性。此外,如果原始和高级 RAG 以“检索和阅读”机制为特征,那么模块化 RAG 允许“检索、阅读和重写”。实际上,通过评估和提供反馈的能力,系统可以优化对查询的响应。

随着这一新范式的传播,人们尝试了有趣的可选方案,例如整合来自 LLM 参数化记忆的信息。在这种情况下,模型在检索之前被要求生成一个响应(背诵和回答)。演示-搜索-预测(DSP)展示了如何通过 LLM 和 RAG 之间的不同交互来解决复杂查询(或知识密集型任务)。DSP 展示了模块化 RAG 如何同时实现稳健和灵活的管道。另一方面,自我反思的检索增强生成(Self-RAG)将批评元素引入系统。LLM 反思它所生成的,从事实性和整体质量的角度对其输出进行批评。另一种选择是使用交错 CoT 生成和检索。这些方法通常在我们有需要推理的问题时效果最好。

训练和无训练方法

RAG 方法分为两组:无训练和基于训练。原始 RAG 方法通常被认为是无训练的。无训练意味着系统的两个主要组件(嵌入器和 LLM)从一开始就被冻结。这是可能的,因为它们是两个预训练的组件,因此已经获得了使我们能够使用它们的技能。

或者,我们可以有三种基于训练的方法:独立训练、顺序训练和联合训练。

在独立训练中,检索器和 LLMs 在完全独立的过程中分别进行训练(训练过程中没有交互)。在这种情况下,我们对系统的各个组成部分进行单独的微调。当我们想要将我们的系统适应到特定领域(例如法律、金融或医疗)时,这种方法很有用。与无训练方法相比,这种类型的训练提高了系统对我们应用领域的功能。LLMs 也可以进行微调,以更好地利用上下文。

顺序训练,另一方面,假设我们按顺序使用这两个组件,因此最好找到一种能够增加这些组件之间协同效应的训练形式。组件可以先独立训练,然后按顺序训练。其中一个组件保持冻结状态,而另一个则进行额外的训练。根据训练的顺序,我们可以有两种类型,检索优先或 LLM 优先:

  • 检索优先:在这个课程中,训练者的训练是先进行的,然后保持冻结状态。然后,训练语言模型(LLM)理解如何在检索器上下文中使用知识。例如,我们独立地对检索器进行微调,然后使用检索到的片段对 LLM 进行微调。LLM 在其微调过程中接收检索器片段,并学习如何最好地使用这个上下文进行生成。

  • LLM 优先:这稍微复杂一些,但它是利用 LLM 的监督来训练检索器。LLM 通常比检索器更强大,因为它有更多的参数,并且已经在更多的标记上进行了训练,因此它是一个很好的监督者。从某种意义上说,这种方法可以被视为一种知识蒸馏,我们利用更大模型的更多知识来训练更小的模型。

训练方法 领域/应用 推理
检索优先 搜索引擎(通用或特定领域)例如,法律文件搜索,医学文献搜索,或电子商务产品搜索 专注于快速准确地检索最相关的文档。对于领域特定精度至关重要的系统,检索器必须处理大量、结构化或半结构化语料库。
企业知识管理例如,内部企业文档,常见问题解答,或 CRM 系统 强调从专有数据库中高效检索正确的文档,其中检索的质量比生成的质量有更大的影响。
科学研究存储库例如,PubMed,arXiv,或专利 确保在高度技术或专业领域中进行精确和召回优化的检索,在这些领域中,高质量的检索对于下游任务(如摘要或报告生成)至关重要。
监管和合规系统例如,金融合规检查,或法律案例法数据库 在准确性和合规性至关重要的领域,检索器必须可靠地呈现最相关的内容,同时最大限度地减少不相关或低置信度的检索。
LLM-first 对话代理例如,客户支持聊天机器人或个人助理 严重依赖 LLM 的生成能力来提供细微、对话式的响应。检索是次要的,因为 LLM 解释并整合检索到的内容。
创意应用例如,内容创作、讲故事或头脑风暴 LLM 从检索数据中创建、综合和推断的能力至关重要。检索通过提供更广泛的环境来支持生成,而不是作为优化的焦点。
复杂推理任务例如,多步骤问题解决或决策系统 LLM 作为推理者的角色超过了检索的精确度,因为重点是处理、关联和推断知识的能力。检索主要确保推理时能够访问补充信息。
教育工具例如,学习助手或个性化辅导系统 LLM 适应并生成针对用户上下文定制的教学内容的能 力比精确检索更重要。检索作为次要机制,确保信息的完整性。

表 6.2 – 训练方法

根据这篇文章(Izacard,arxiv.org/abs/2012.04584),LLM 中的注意力激活值是定义文档相关性的良好代理,因此它们可以用来为检索器提供标签(一种指南),以说明搜索结果有多好。因此,检索器使用基于 LLM 中注意力的度量进行训练。对于一种更经济的方案,可以使用一个小型 LLM 来生成标签,然后训练检索器。这些方法有各种变体,但所有方法都基于这样一个原则:一旦我们微调了 LLM,我们希望使检索器与之对齐。

另一方面,联合方法代表系统的端到端训练。换句话说,检索器和生成器同时(同时)对齐。我们的想法是希望系统同时提高其发现知识的能力和使用这些知识进行生成的能力。优势在于我们在训练期间有协同效应。

图 6.15 – RAG 中的不同训练方法(img/B21257_06_15.jpg)

图 6.15 – RAG 中的不同训练方法(arxiv.org/pdf/2405.06211)

现在我们知道了我们可以应用到我们的 RAG 上的不同修改,让我们在下一节尝试它们。

实施高级 RAG 管道

在本节中,我们将描述如何实现高级 RAG 管道。在这个管道中,我们使用朴素 RAG 的更高级版本,包括一些附加组件来改进它。这表明我们的起始基础是一个经典的 RAG 管道(嵌入、检索和生成),但插入了一些更复杂的组件。在这个管道中,我们使用了以下附加组件:

  • 重排器:这允许我们在检索步骤中找到的上下文中进行排序。这是高级 RAG 中最广泛使用的元素之一,因为它已被证明可以显著提高结果。

  • 查询转换:在这种情况下,我们使用简单的查询转换。这是因为我们希望尝试扩大我们的检索范围,因为一些相关文档可能会被遗漏。

  • 查询路由:这使我们能够避免对所有查询一视同仁,并允许我们为更有效的检索建立规则。

  • 混合搜索:通过这种方式,我们将基于关键词的搜索的强大功能与语义搜索相结合。

  • 摘要:通过这种方式,我们尝试从检索到的上下文中消除冗余信息。

当然,我们可以添加其他组件,但通常,这些是最常用的,并概述了我们可以添加到朴素 RAG 中的组件。

我们可以在以下图中看到我们的管道是如何修改的:

图 6.16 – 高级 RAG 的管道

图 6.16 – 高级 RAG 的管道

完整的代码可以在仓库中找到;在这里,我们只看重点。在这个代码片段中,我们定义了一个函数来表示查询转换。在这种情况下,我们只是在查询中进行了小的修改(搜索查询中的其他相关术语):

def advanced_query_transformation(query):
    """
    Transforms the input query by adding synonyms, extensions, or modifying the structure
    for better search performance.
    Args:
        query (str): The original query.
    Returns:
        str: The transformed query with added synonyms or related terms.
    """
    expanded_query = query + " OR related_term"
    return expanded_query

接下来,我们执行查询路由。查询路由强制执行一个简单的规则:如果查询中存在特定关键词,则执行基于关键词的搜索;否则,使用语义(基于嵌入)搜索。在某些情况下,我们可能首先只想检索包含某些关键词的文档——例如,对特定产品的引用——然后使用语义搜索进一步缩小结果:

def advanced_query_routing(query):
    """
    Determines the retrieval method based on the presence of specific keywords in the query.
    Args:
        query (str): The user's query.
    Returns:
        str: 'textual' if the query requires text-based retrieval, 'vector' otherwise.
    """
    if "specific_keyword" in query:
        return "textual"
    else:
        return "vector"

接下来,我们执行混合搜索,这使我们能够使用基于语义和关键词内容的搜索。这是今天 RAG 管道中最广泛使用的组件之一。当使用分块时,有时只有包含关键词的文档与查询相关(例如,产品的名称、人名等)。显然,并非所有包含关键词的分块都是相关文档(特别是对于我们更感兴趣于语义概念的查询)。使用混合搜索,我们可以平衡两种类型的搜索,选择从一种或另一种类型的搜索中取多少分块:

def fusion_retrieval(query, top_k=5):
    """
    Retrieves the top_k most relevant documents using a combination of vector-based
    and textual retrieval methods.
    Args:
        query (str): The search query.
        top_k (int): The number of top documents to retrieve.
    Returns:
        list: A list of combined results from both vector and textual retrieval methods.
    """
    query_embedding = sentence_model.encode(query).tolist()
    vector_results = collection.query(query_embeddings=[query_embedding], n_results=min(top_k, len(documents)))
    es_body = {
        "size": top_k,  # Move size into body
        "query": {
            "match": {
                "content": query
            }
        }
    }
    es_results = es.search(index=index_name, body=es_body)
    es_documents = [hit["_source"]["content"] for hit in es_results['hits']['hits']]
    combined_results = vector_results['documents'][0] + es_documents
    return combined_results

如前所述,重排器是使用最频繁的元素之一;它是一个用于重新排序上下文的 transformer。如果我们找到了 10 个片段,我们会重新排序找到的片段,并通常取它们的一个子集。有时,语义搜索可以再次找到最相关的片段,但这些片段可能被放置在顺序的更下方。重排器确保这些片段实际上被放置在 LLM 的上下文中:

def rerank_documents(query, documents):
    """
    Reranks the retrieved documents based on their relevance to the query using a pre-trained
    BERT model.
    Args:
        query (str): The user's query.
        documents (list): A list of documents retrieved from the search.
    Returns:
        list: A list of reranked documents, sorted by relevance.
    """
    inputs = [rerank_tokenizer.encode_plus(query, doc, return_tensors='pt', truncation=True, padding=True) for doc in documents]
    scores = []
    for input in inputs:
        outputs = rerank_model(**input)
        logits = outputs.logits
        probabilities = F.softmax(logits, dim=1)
        positive_class_probability = probabilities[:, 1].item()
        scores.append(positive_class_probability)
    ranked_docs = sorted(zip(documents, scores), key=lambda x: x[1], reverse=True)
    return [doc for doc, score in ranked_docs]

如前所述,上下文也可能包含冗余信息。LLM 对噪声很敏感,因此减少这种噪声可以帮助生成。在这种情况下,我们使用一个 LLM 来总结找到的上下文(当然,我们设定了一个限制,以避免丢失太多信息):

def select_and_compress_context(documents):
    """
    Summarizes the content of the retrieved documents to create a compressed context.
    Args:
        documents (list): A list of documents to summarize.
    Returns:
        list: A list of summarized texts for each document.
    """
    summarized_context = []
    for doc in documents:
        input_length = len(doc.split())
        max_length = min(100, input_length)  than 100
        summary = summarizer(doc, max_length=max_length, min_length=5, do_sample=False)[0]['summary_text']
        summarized_context.append(summary)
    return summarized_context

一旦定义,我们只需将它们组装成一个单一的管道。一旦完成,我们就可以使用我们的 RAG 管道。检查存储库中的代码并尝试修改代码。一旦你有一个可以工作的 RAG 管道,下一步自然就是部署。在下一节中,我们将讨论部署可能面临的潜在挑战。

理解 RAG 的可扩展性和性能

在本节中,我们将主要描述与 RAG 系统部署相关或随着系统扩展可能出现的挑战。与 LLM 相比,RAG 的主要优势在于它可以不进行额外训练而进行扩展。开发和生产的目的和需求主要不同。LLM 和 RAG 提出了新的挑战,尤其是在你希望将系统投入生产时。生产化意味着将像 RAG 这样的复杂系统从原型转变为稳定、可操作的环境。当你必须管理可能远程连接的不同用户时,这可能会非常复杂。在开发过程中,准确性可能是最重要的指标,而在生产过程中,必须特别小心地平衡性能和成本。

尤其是大型组织,可能已经存储了大量的数据,因此可能希望使用 RAG 与这些数据结合。大数据对 RAG 系统来说可能是一个重大的挑战,特别是考虑到数据的量、速度和多样性。"可扩展性"在讨论大数据时是一个关键问题;同样的原则也适用于 RAG。

数据可扩展性、存储和预处理

到目前为止,我们已经讨论了如何查找信息。我们假设数据是以文本形式存在的。文本的数据结构是一个重要的参数,将其投入生产可能会遇到问题。因此,我们的系统可能需要整合以下内容:

  • 非结构化数据:文本是语料库中最常用的数据类型。它可以有不同的来源:百科全书式(来自维基百科),特定领域(科学、医学或金融),行业特定(报告或标准文件),从互联网下载,或用户聊天。因此,它可以由人类生成,但也可能包括由自动化系统或 LLMs 本身(与用户的先前交互)生成的数据。此外,它可能是多语言的,系统可能需要进行跨语言搜索。今天,既有用不同语言训练的 LLMs,也有多语言嵌入器(专门设计用于多语言能力)。还有其他类型的非结构化数据,如图像和视频。我们将在下一节更详细地讨论多模态 RAG。

  • 半结构化数据:通常,这意味着包含文本和表格信息的混合数据(如 PDF)。半结构化数据的其他例子包括 JSON、XML 和 HTML。这些类型的数据通常很难与 RAG 一起使用。通常有特定于文件的管道(分块、元数据存储等),因为它们可能会给系统带来问题。在 PDF 的情况下,分块可以将表格分成多个块,使得检索效率低下。此外,表格使相似性搜索更加复杂。一种替代方法是提取表格并将它们转换为文本或插入到兼容的数据库中(如 SQL)。由于可用的方法尚未优化,该领域的研究仍然非常活跃。

  • 结构化数据:结构化数据是指以标准格式存储的数据,可以由人类和软件高效访问。结构化数据通常具有一些特殊特征:定义了属性(所有数据值都使用表格中的相同属性),关系属性(表具有将不同数据集连接起来的公共值;例如,在客户数据集中,有 ID 可以找到用户及其购买记录),定量数据(数据优化用于数学分析),以及存储(数据以特定格式和精确规则存储)。结构化数据的例子包括 Excel 文件、SQL 数据库、网页表单结果、销售点数据和产品目录。另一个结构化数据的例子是知识图谱(KGs),我们将在下一章详细讨论。

这些因素必须被考虑在内。例如,如果我们正在设计一个需要在各个地区和不同语言中搜索合规文件的系统,我们需要一个能够进行跨语言检索的 RAG。如果我们组织主要有一种类型的数据(PDF 或 SQL 数据库),那么考虑这一点并优化系统以搜索此类数据是很重要的。有一些特定的替代方案可以改善 RAGs 处理结构化数据的能力。一个例子是链表,这是一种将 CoT 提示与表转换相结合的方法。在 LLM 和一组预定义操作的逐步过程中,它提取并修改表格。这种方法旨在处理复杂的表格,并利用逐步推理和逐步表格操作来完成这一任务。这种方法在数据源为复杂的 SQL 数据库或大量数据框时很有用。然后,还有更复杂的替代方案,它们结合了符号推理和文本推理。混合自洽是一种针对表格数据理解的专用方法,它使用文本和符号推理以及自洽性,从而创建推理的多路径,然后通过自洽性进行聚合。对于 PDF 和 JHTML 等半结构化数据,有专门的包允许我们从它们中提取信息或解析数据。

不仅数据类型会影响 RAG 的性能,数据量本身也会影响。随着数据量的增加,找到相关信息变得越来越困难。同样,这也可能增加系统的延迟。

数据存储是在将系统投入生产之前需要解决的焦点之一。分布式存储系统(将数据分割成几个物理服务器或数据中心的基础设施)可以是大数据量的解决方案。这具有提高系统速度和降低数据丢失风险的优点,但可能会增加成本和管理复杂性。当你有不同类型的数据时,使用称为数据湖的结构可能是有利的。数据湖是一个设计用于存储和处理结构化、半结构化和非结构化数据的集中式存储库。数据湖的优势在于它是一个可扩展且灵活的结构,用于摄取、处理和存储不同类型的数据。数据湖对 RAG 有利,因为它允许比其他数据结构维护更多的数据上下文。另一方面,数据湖需要更多的专业知识才能发挥作用。替代方案可能包括将数据分割成更小、更易于管理的分区(基于地理位置、主题、时间等),这允许更有效的检索。在大量请求的情况下,频繁访问的数据缓存可以避免重复。这些策略可以在大数据存储和访问的情况下使用。

另一个重要的方面是构建用于数据预处理和清洗的稳固管道。在开发阶段,通常与经过良好打磨的数据集一起工作,但在生产中并非如此。特别是在大数据中,确保没有不一致性或系统可以处理缺失或不完整的数据至关重要。在大数据环境中,数据来自许多来源,并非所有来源都是高质量的。因此,可以使用插补技术(如 KNN 或其他)来填补缺失数据。其他可以改进流程的补充包括消除噪声或错误数据的技巧,例如异常检测算法、归一化技术和用于消除错误数据点的正则表达式技术。

数据去重是处理 LLMs 时另一个重要的方面。重复数据会损害 LLMs 的训练,在生成过程中被发现时也会造成损害(可能导致不准确、有偏见或质量低下的输出)。随着数据量的增加,数据重复的风险会线性增加。可以使用模糊匹配和基于哈希的去重技术来消除重复元素。通常,应该创建一个管道来控制系统中数据的质量和治理(数据质量监控)。这些管道应包括规则和跟踪系统,以便能够识别有问题的数据和其来源。尽管这些管道是必不可少的,但过于复杂难以维护或过多地减慢系统速度的管道应避免。

一旦我们确定了我们的数据存储基础设施,我们需要确保我们拥有高效的数据索引和检索。有一些索引方法专门针对大数据,例如 Apache Lucene 或 Elasticsearch。此外,最常用的数据可以被缓存,或者检索过程可以被分布式以创建并行基础设施,并在有多个用户时减少瓶颈。鉴于这些技术的复杂性,在投入生产之前进行测试和基准测试总是最好的做法。

并行处理

尤其对于拥有大量用户的软件应用,并行处理可以显著提高系统可扩展性。这显然需要一个良好的云基础设施,以及组织良好的集群。将并行处理应用于 RAG 可以显著降低系统延迟,即使存在大量数据集。Apache Spark 和 Dask 是实现 RAG 并行计算最广泛使用的解决方案之一。正如我们所见,并行计算可以在 RAG 管道各个阶段实现:存储、检索和生成。在存储阶段,可以使用各个节点来执行整个数据预处理管道,即预处理、索引和部分数据集(直到嵌入)的块化。尽管这看起来不太直观,但在检索阶段,数据集可以分配给各个节点,每个节点负责从特定的数据集分片中查找信息。这样,我们减轻了每个节点的计算负担,并使检索过程并行化。

类似地,生成过程也可以并行化。实际上,LLMs 计算密集,但基于 Transformer。Transformer 的设计考虑了训练和推理的并行化。存在一些技术可以在长序列或大数据批量情况下实现并行化。后来,开发了更复杂的技巧,例如张量并行、模型并行和专用框架。然而,并行化系统本身存在固有的挑战和出现错误的风险。因此,在系统使用期间监控系统并实施容错机制(如检查点)、高级调度(如动态任务分配)和其他潜在解决方案是很重要的。

RAG 是一个资源密集型过程(或者至少某些步骤是),因此实施动态分配资源和监控各种进程的工作负载的技术是很好的做法。此外,建议使用模块化方法,将各种组件(如数据摄取、存储、检索和生成)分开。无论如何,建议有一个过程来监控不仅准确性方面的性能,还包括内存使用、成本、网络使用等方面。

图 6.17 – RAG 可扩展性的大数据解决方案

图 6.17 – RAG 可扩展性的大数据解决方案

我们已经一般性地讨论了 RAG。然而,正如我们之前看到的,今天的 RAG 可以由几个组件组成。通过高级 RAG 和模块化 RAG,我们看到了如何通过添加额外的组件快速扩展系统,这些组件会影响系统的准确性和计算及延迟成本。因此,我们的系统有许多替代方案,很难选择哪些组件最重要。迄今为止,只有少数基准研究对性能和计算成本进行了严格的分析。在最近的一项研究中(王,2024),作者分析了潜在的最佳组件,并提供了关于使用哪些元素的指导。在 *图 6**.18 中,标记为蓝色的组件是研究作者认为能提供最佳性能的组件,而加粗的则是可选组件。

图 6.18 – 对最佳 RAG 每个组件的贡献](https://github.com/OpenDocCN/freelearn-dl-zh/raw/master/docs/bd-ai-agt-llm-rag-kg/img/B21257_06_18.jpg)

图 6.18 – 对最佳 RAG 每个组件的贡献(arxiv.org/pdf/2407.01219)

例如,添加一些组件可以提高系统准确性,但延迟也会明显增加。HyDE 实现了最高的性能分数,但似乎有显著的计算成本。在这种情况下,性能提升并不能证明这种增加的延迟是合理的。其他组件增加了计算成本,但它们的缺失会导致性能显著下降(这种情况发生在重新排序中)。摘要模块有助于模型实现最佳准确性;如果延迟不是问题,它们的成本是可以接受的。尽管在系统性的搜索中测试所有组件几乎是不可能的,但可以提供一些指导方针。最佳性能是通过查询分类模块 HyDE、重新排序模块、上下文重组和摘要实现的。然而,如果从计算或延迟的角度来看成本过高,则最好避免使用 HyDE 等技术,并坚持使用其他模块(例如,选择参数更少的重新排序器)。以下表格总结了单个模块和技术的性能和计算效率:

图 6.19 – 单个模块和技术对准确性和延迟的影响](https://github.com/OpenDocCN/freelearn-dl-zh/raw/master/docs/bd-ai-agt-llm-rag-kg/img/B21257_06_19.jpg)

图 6.19 – 单个模块和技术对准确性和延迟的影响(arxiv.org/pdf/2407.01219)

此外,还有专门为 RAG 设计的并行化策略。LlamaIndex 提供了一种并行管道用于数据摄取和处理。为了提高系统的鲁棒性,还有防止错误的系统。例如,在使用模型时,你可能会遇到运行时错误(特别是如果你使用外部 API,如 OpenAI 或 Anthropic)。在这些情况下,拥有后备模型是有益的。LLM 路由器是一种允许你将查询路由到不同 LLM 的系统。通常,有一个预测模型来智能地决定哪个 LLM 最适合给定的提示(考虑到潜在的准确性或成本等因素)。这些路由器可以用作封闭源模型,或者将查询路由到不同的外部 LLM API。

安全和隐私

当系统投入生产时,需要考虑的一个重要方面是系统的安全和隐私。RAG 可以处理大量敏感和机密数据;系统被破坏可能导致组织遭受毁灭性的后果(例如监管罚款、诉讼、声誉损害等)。其中一个主要的解决方案是数据加密。一些算法和协议在业界得到广泛应用,也可以应用于 RAG(例如,AES-256 和 TLS/SSL)。同样,实施内部政策以保护密钥并频繁更换它们也很重要。此外,必须实施凭证和权限系统,以确保用户受控访问。如今,使用如多因素认证(MFA)、强密码规则以及多设备访问策略是良好的实践。再次强调,这其中的一个重要部分是对潜在破坏的持续监控、事件报告以及如果发生事件时的政策。在部署之前,对系统和其鲁棒性进行测试以识别潜在漏洞是至关重要的。

隐私是当今一个关键且日益敏感的话题。系统遵守关键法规,如通用数据保护条例(GDPR)和加州消费者隐私法案(CCPA)非常重要。特别是在处理大量个人数据时,违反这些法规会使组织面临巨额罚款。为了避免处罚,实施强大的数据治理、跟踪实践和数据管理是明智之举。还有一些技术可以用来提高系统隐私,例如差分隐私和安全的多方计算。此外,应跟踪事件,并应制定处理问题和解决问题的政策。

图 6.20 – RAG 系统和潜在风险 (https://arxiv.org/pdf/2402.16893)

图 6.20 – RAG 系统和潜在风险(arxiv.org/pdf/2402.16893)

然后,目前存在一些针对 RAG 系统的特定安全问题。例如,向量可能看起来像是简单的数字,但实际上可以转换回文本。嵌入过程可以被视为有损的,但这并不意味着它不能解码回原始文本。理论上,嵌入向量应仅保持原始文本的语义意义,从而保护敏感数据。实际上,在某些研究中,他们已经能够恢复原始文本中超过 70%的单词。此外,不需要极其复杂的技巧。在所谓的嵌入反转攻击中,你获取向量并将它们解码回原始文本。换句话说,与普遍看法相反,你可以从向量中重建文本,因此这些向量也应受到保护。此外,任何包含 LLM 的系统都容易受到提示注入攻击。这是一种看似合法的提示,其中添加了恶意指令。这可能是为了提示模型泄露信息。提示注入是模型面临的最大风险之一,通常,文献中会描述新的方法,因此所有先前的预防措施很快就会过时。此外,特定的提示可能会诱导 RAG 产生非预期的输出。对抗性前缀是添加到 RAG 提示中的前缀,可以诱导生成幻觉和不准确的事实输出。

另一种攻击类型是毒化 RAG,其目的是输入错误的数据,然后 LLM 会使用这些数据生成偏颇的输出。例如,为了生成虚假信息,我们可以构建目标文本,当注入时会导致系统生成期望的输出。在图例的例子中,我们注入文本以毒化 RAG 来影响问题的答案。

图 6.21 – 毒化 RAG 概述 (https://arxiv.org/pdf/2402.07867)

图 6.21 – 毒化 RAG 概述 (arxiv.org/pdf/2402.07867)

成员推理攻击(MIAs)是另一种攻击类型,其目的是推断某些数据是否存在于数据集中。如果一个样本位于 RAG 数据集中,它可能会在特定查询中被找到,并插入到 LLM 的上下文中。通过 MIAs,我们可以知道数据是否存在于系统中,然后尝试通过提示注入(例如,通过让 LLM 输出检索到的上下文)来提取它。

正因如此,针对 RAG(或更普遍的 LLMs)有特定的解决方案。一个例子是NeMo Guardrails,这是一个由 NVIDIA 开发的开源工具包,旨在为基于 LLM 的应用程序添加可编程轨道。这些轨道提供了一种控制模型 LLM 输出的机制(因此我们直接在生成级别进行操作)。通过这种方式,我们可以提供约束(不涉及有害话题、在对话中遵循路径、不回应某些请求、使用特定语言等)。与其他嵌入式技术(如训练时的模型对齐)相比,这种方法的优势在于它发生在运行时,我们不需要对模型进行额外的训练。这种方法也是模型无关的,通常,这些轨道是可解释的(在对齐过程中,我们应该分析用于训练的数据集)。NeMo Guardrails 通过一种可解释的语言(称为 Colang)实现用户定义的可编程轨道,允许我们为 LLMs 定义行为规则。

使用这个工具包,我们可以使用不同类型的轨道:输入轨道(拒绝输入、进行进一步处理或修改输入,以避免敏感信息泄露)、输出轨道(在内容有问题的情况下拒绝生成输出)、检索轨道(拒绝块并因此不将其放入 LLM 的上下文中,或更改现有块),或对话轨道(决定是否执行操作、使用 LLM 进行下一步,或使用默认响应)。

图 6.22 – LLMs 的可编程与嵌入式轨道对比( https://arxiv.org/abs/2310.10501 )

图 6.22 – LLMs 的可编程与嵌入式轨道对比(arxiv.org/abs/2310.10501)

另一方面,Llama Guard是一个旨在检查输入(通过提示分类)和输出(通过响应分类)并判断文本是否安全或不安全的系统。然后,这种方法使用 Llama 2 进行分类,并使用专门调整的 LLM 作为评判者。

开放性问题与未来展望

尽管 RAG 技术在很大程度上取得了进步,但仍然存在挑战。在本节中,我们将讨论这些挑战和前景。

最近,关于 LLM(大型语言模型)上下文长度扩展的话题引起了广泛的兴趣和讨论。如今,大多数表现最好的 LLM 的上下文长度超过 100K 个 token(有些甚至超过 100 万个)。这种能力意味着模型具有进行长文档问答的能力(换句话说,能够在单个提示中插入如书籍等长文档)。1 到 1000 万个 token 的上下文长度可以覆盖许多小型用例。长上下文 LLM(LC-LLM)的优势在于它能够对提示中的信息进行交错检索和生成,并对整个文档进行一次性推理。特别是在摘要任务中,LC-LLM 具有竞争优势,因为它可以对整个文档进行扫描,并将文档顶部和底部出现的信息联系起来。对一些人来说,LC-LLM 意味着 RAG(检索-生成)注定要消失。

事实上,LC-LLM 并不与 RAG 竞争,RAG 在短期内也不注定要消失。LC-LLM 并没有高效地使用整个框架。特别是,上下文中中间的信息被关注得要少得多。同样,推理受到无关信息的影响,而长的提示不可避免地提供了回答查询所需的不必要的大量细节。LC-LLM 的幻觉比 RAG 要多得多,后者允许进行参考检查(使用了哪些文档,从而使检索和推理过程变得可观察和透明)。LC-LLM 在处理结构化数据(许多行业中的大多数数据)方面也存在困难,并且成本相当高(长提示会导致延迟显著增加,以及每查询的成本)。最后,考虑到即使是小型组织拥有的数据量,100 万个 token 也不是很多(因此检索总是必要的)。

LC-LLM 为开发者开辟了令人兴奋的可能性。首先,这意味着精确的分块策略将很少需要。分块可以更大(每个分块可以是一个文档,或者至少是一组页面)。这将意味着减少对粒度和性能之间平衡的需求。其次,需要更少的提示工程。特别是对于推理任务,一些问题可以用一个分块中的信息来回答,但其他问题则需要在不同部分或多个文档中进行深入分析。而不是复杂的 CoT(概念重叠),可以用单个提示来回答这些问题。第三,使用 LC-LLM 进行摘要更容易,因此可以单次检索完成。最后,LC-LLM 允许更好地定制和与用户交互。在这样的长提示中,可以上传与用户整个对话。尽管如此,仍然存在一些开放性的挑战,尤其是在为 LC-LLM 检索文档方面。

同样,目前还没有能够处理类似上下文长度的嵌入模型(目前,嵌入器的最大上下文长度为 32K)。因此,即使有 LC-LLM,块的大小也不能超过 32K。LC-LLM 在性能方面仍然很昂贵,并且可能会严重影响系统的可扩展性。无论如何,已经有研究正在探讨一些考虑 LC-LLM 的潜在 RAG 变体——例如,在从小到大的检索中,你找到必要的块,然后发送与 LC-LLM 关联的整个文档,或者将查询路由到管道化整个文档检索(如整个文档摘要任务)或找到块(特定问题或需要不同文档块的多部分问题)。许多公司使用 KV 缓存,这是一种在生成过程中存储来自键和注意力层的激活以及查询的方法(这样你就不必在整个序列生成过程中重新计算整个激活)。因此,有人提出,RAG 也可以用来查找缓存

我们可以在以下图中直观地看到这些可能的演变:

图 6.23 – RAG 与 LC-LLM 可能的演变

图 6.23 – RAG 与 LC-LLM 可能的演变

  • A. 首先检索块,然后检索相关的文档

  • B. 路由器决定是否需要检索小块或整个文档

  • C. 首先检索文档,然后为 LC-LLM 进行 KV 缓存

多模态 RAG是一个令人兴奋的前景和挑战,已经被讨论过。大多数组织不仅拥有文本数据,还有大量其他模态的数据(图像、音频、视频等)。此外,许多文件可能包含不止一种模态(例如,一本书不仅包含文本,还包含图像)。在不同的上下文和应用中搜索多模态数据可能特别有趣。另一方面,多模态 RAG 的复杂性在于每个模态都有其自身的挑战。我们有几种不同的方法可以实现多模态 RAG。我们将看到三种可能的策略:

  • 将所有模态嵌入到相同的向量空间中:我们之前在第三章(一个通过对比学习训练以实现图像和文本独特嵌入的模型)中看到了这种情况,它允许我们同时搜索图像和文本。我们可以使用像 CLIP 这样的模型来对所有模态进行嵌入(在这种情况下,是图像和文本,但还存在其他跨模态模型)。然后我们可以找到图像和文本,并使用多模态模型进行生成(例如,我们可以使用 BLIP2 或 BLIP3 作为视觉语言模型)。多模态模型可以对图像和文本进行推理。这种方法的优势在于我们只需要更改嵌入模型到我们的系统中。此外,多模态模型可以通过利用图像和文本中的信息来进行推理。例如,如果我们有一个包含表格的 PDF,我们可以找到感兴趣的片段及其相关的图表。模型可以使用两种模态中包含的信息来更有效地回答查询。缺点是 CLIP 是一个昂贵的模型,多模态大型语言模型(MMLLMs)比仅文本的 LLMs 更昂贵。此外,我们需要确保我们的嵌入模型能够捕捉到图像和文本的所有细微差别。

  • 单基础模态:另一个选择是将所有模式转换为基本模式(这取决于应用的焦点)。例如,我们从 PDF 中提取文本,并为每个图像创建文本描述以及元数据(对于音频,我们可以使用转录)。在某些变体中,我们保留存储中的图像。在检索过程中,我们再次找到文本(因此我们使用经典的嵌入模型和仅包含从文本中获得的向量的数据库)。然后我们可以在生成阶段使用 LLM 或 MMLLM(如果我们想添加通过检索元数据或描述获得的图像)。再次,主要优势是我们不必训练任何新的模型类型,但作为一种方法,它可能很昂贵,并且我们失去了图像的一些细微差别。

  • 为每个模态分别检索:在这种情况下,每个模态都是单独嵌入的。例如,如果我们有三个模态,我们将有三个单独的模型(音频-文本对齐模型、图像-文本对齐模型和文本嵌入器)和三个单独的数据库(音频、图像和文本)。当查询到达时,我们为每个模式进行编码(因此是音频、图像和文本)。所以,在这种情况下,我们进行了三次检索,可能会找到不同的元素,因此有一个重新排序步骤(以有效地组合结果)是值得的。显然,我们需要一个专门的多模态重新排序器,以便我们可以检索最相关的块。它简化了组织,因为我们有针对每个模式的专用模型(一个对所有模式都工作得很好的模型很难获得),但它增加了系统的复杂性。同样,虽然一个经典的重新排序器必须重新排序n个块,但一个多模态重新排序器的复杂性是重新排序m x n个块(其中m是模态的数量)。

    最后,一旦获得了多模态块,可能会有替代方案;例如,我们可以使用一个 MMLM 来生成响应,然后这个响应需要被整合到上下文中以形成一个最终的 LLM。正如我们之前看到的,我们的 RAG 管道可以比简单的 RAG 更复杂。然后我们可以将之前看到的所有元素组合成一个单一的系统。

图 6.24 – 多模态 RAG 的三个潜在方法

图 6.24 – 多模态 RAG 的三个潜在方法

尽管 RAG 有效地缓解了幻觉,但它们仍然可能发生。我们之前已经讨论过幻觉是 LLM 的灾难。在本节中,我们将主要讨论 RAG 中的幻觉。其中最奇特的情况之一是情境幻觉,在这种幻觉中,正确的信息在上下文中提供,但 LLM 仍然生成错误的输出。尽管模型提供了正确的信息,但它产生了错误的答案(这种情况通常发生在摘要或基于文档的问题等任务中)。这是因为在 LLM 中存在自己的先验知识,假设模型不使用这种内部知识是错误的。此外,模型经过指令微调或以其他方式对齐,因此它隐式地做出决定,是使用上下文还是忽略上下文并使用其知识来回答用户的问题。在某些情况下,这甚至可能是有用的,因为可能我们找到了错误或误导性的上下文。总的来说,对于许多闭源模型,我们不知道它们是在什么上进行训练的,尽管我们可以监控它们对答案的信心。给定一个问题 x,模型将回答一个答案 x。根据其知识,这将有一个信心 c(这是基于模型生成的标记的概率)。基本上,一个模型对其答案越自信,它在上下文暗示不同的情况下改变答案的可能性就越小。一个有趣的发现是,如果正确答案与 LLM 的知识略有不同,LLM 很可能会改变其答案。在存在较大差异的情况下,LLM 将选择自己的答案。例如,对于“药物 x 的最大剂量是多少?”这个问题,模型可能在训练中看到了 20 µg。如果上下文暗示是 30,LLM 将提供 30 作为输出;如果上下文暗示是 100,LLM 将声明 20。较大的 LLM 通常更自信,更喜欢自己的答案,而较小的模型更愿意使用上下文。最后,这种行为可以通过提示工程来改变。更严格的提示将迫使模型使用上下文,而较弱的提示将推动模型使用其先验知识。

图 6.25 – 标准提示与宽松或严格提示的比较示例 (https://arxiv.org/pdf/2404.10198)

图 6.25 – 标准提示与宽松或严格提示的比较示例 (arxiv.org/pdf/2404.10198)

其他因素也有助于减少 RAG 中的幻觉:

  • 数据质量:数据质量通常对系统质量有重大影响。

  • 情境意识:LLM 可能并不完全理解用户的意图,或者找到的上下文可能不是正确的。查询重写和其他高级 RAG 组件可能是解决方案。

  • 负面拒绝:当检索未能找到查询的适当上下文时,模型仍然尝试做出回应,从而产生幻觉或错误答案。这通常是由于查询编写不当造成的,因此可以通过修改查询的组件(如 HyDE)来改进。或者,更严格的提示会迫使 LLM 只有在有上下文的情况下才做出回应。

  • 推理能力:一些查询可能需要推理或过于复杂。系统的推理限制取决于 LLM;RAG 是为了找到回答查询的上下文。

  • 领域不匹配:通用模型在处理过于技术化的领域时会遇到困难。微调嵌入器和 LLM 可以是一个解决方案。

  • 目标不匹配:嵌入器和 LLM 的目标不一致,因此今天有系统试图优化端到端检索和生成。这可以解决复杂查询或特定领域的问题。

还有其他令人兴奋的视角。例如,有一些工作正在研究使用强化学习来提高 RAG 对复杂查询的响应能力。其他研究涉及整合图研究;我们将在下一章中更详细地讨论这一点。此外,我们迄今为止一直假设数据库是静态的,但在互联网时代,有一个关于如何将互联网整合到 RAG 中的讨论(例如,在组织受保护的数据中进行混合搜索,并通过互联网搜索找到上下文)。这提出了令人兴奋但复杂的问题,例如是否进行数据库更新、如何过滤掉不相关的搜索引擎结果以及安全问题。此外,还有越来越多的 RAG 专用应用,作者专注于创建针对其应用领域的优化系统(例如,用于数学、医学、生物学等)。所有这些都表明了 RAG 的活跃研究和对其应用的兴趣。

摘要

在本章中,我们最初讨论了朴素 RAG 的问题。这使得我们看到了许多可以用来解决朴素 RAG 痛点的附加组件。使用这些附加组件是现在所说的先进 RAG 范式的基础。随着时间的推移,社区随后转向了一种更灵活和模块化的结构,现在称为模块化 RAG。

我们随后看到了如何在大数据存在的情况下扩展这种结构。像任何基于 LLM 的应用一样,当你需要将系统从开发环境迁移到生产环境时,会面临计算和成本挑战。此外,LLM 和 RAG 都可能存在安全和隐私风险。这些是重要的问题,尤其是当这些产品向公众开放时。今天,对合规性的关注越来越多,越来越多的法规正在被考虑。

最后,我们注意到一些问题仍然悬而未决,例如与长上下文 LLM 的关系或这些模型的跨模态扩展。此外,检索和生成之间存在微妙的平衡,我们在出现问题时探讨了潜在解决方案。最近,对与知识图谱(KG)的集成进行了积极的研究。GraphRAG 今天经常被讨论;在下一章中,我们将讨论什么是知识图谱以及图与 RAG 之间的关系。

进一步阅读

第七章:创建和连接知识图谱到 AI 代理

在前两章中,我们详细讨论了 RAG 框架。我们从简单的 RAG 开始,然后看到了我们如何添加不同的组件,替换其他组件,或修改整个管道以满足我们的需求。整个系统非常灵活,但有些概念保持不变。首先,我们从语料库(或多个文本语料库)开始,对这些文本进行嵌入以获得向量数据库。一旦用户查询到达,我们就对这个向量数据库进行相似度搜索。无论文本的范围或类型如何,我们的管道都基于以某种方式对文本进行矢量化,然后向 LLM 提供发现的文本中包含的信息。

文本通常充满了冗余信息,在上一章中,我们看到了 LLMs 对输入中噪声量的敏感性。大多数人已经看到了创建图表笔记或思维导图的好处。这些图表之所以简洁,是因为在书中划线一切就像没有划线一样。这些图表的原则是提取关键信息以便我们能够记住,这将使我们能够回答未来的问题。图表应该展示基本信息和连接它们的关系。这些模式可以表示为图形,更精确地说,是知识图谱。这些图形的优点是它们紧凑,将知识表示为实体和关系,并且我们可以对它们进行分析和使用图搜索算法。多年来,这些知识图谱(KGs)由主要公司或机构构建,现在可供使用。许多这些 KGs 已被用于信息提取,其中信息通过一系列查询来提取以回答问题。这些提取的信息是一系列实体和关系,知识丰富但对我们人类来说不太容易理解。自然的下一步是使用这些信息为 LLM 的上下文生成自然语言响应。这种范式被称为GraphRAG,我们将在本章中详细讨论。

在任何情况下,没有什么阻止我们使用 LLM 在 KG 的所有步骤中。事实上,LLMs 具有许多固有的能力,即使对于它们未经过训练的任务也很有用。这正是我们将看到我们可以使用 LLMs 来提取关系和实体并构建我们的 KGs 的原因。然而,LLMs 也具备推理能力,在本章中,我们将讨论我们如何使用这些模型来推理图中包含的信息以及图的结构本身。最后,我们将讨论哪些观点和问题仍然是开放的,以及所提出方法的优缺点。

在本章中,我们将讨论以下主题:

  • 知识图谱简介

  • 使用你的 LLM 创建知识图谱

  • 使用知识图谱和大型语言模型检索信息

  • 理解图推理

  • 知识图谱和 GraphRAG 的持续挑战

技术要求

大部分代码都可以在 CPU 上运行,但更倾向于在 GPU 上运行。代码是用 PyTorch 编写的,大部分使用标准库(PyTorch、Hugging Face Transformers、LangChain、ChromaDB、sentence-transformer、faiss-cpu等)。

在本章中,我们也将使用 Neo4j 作为图数据库。尽管我们将使用 Python 进行所有操作,但 Neo4j 必须安装,并且您必须注册才能使用它。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr7。

知识图谱简介

知识表示是人工智能的开放问题之一,并且有着非常悠久的历史(莱布尼茨认为所有知识都可以被表示并用于计算)。对知识表示的兴趣基于这样一个事实,即它是进行计算机推理的第一步。一旦这些知识被有序地组织起来,就可以用来设计推理算法和解决推理问题。早期的研究主要集中在使用演绎法来解决有关有序实体的问题(例如,通过使用本体)。这对于许多玩具问题来说效果很好,但它很费力,通常需要一套硬编码的规则,并且存在陷入组合爆炸的风险。因为这些空间中的搜索可能极其计算密集,因此尝试定义了两个概念:

  • 有限理性:找到解决方案的同时,也要考虑其成本

  • 启发式搜索:限制搜索空间,从而找到半优解(局部但非全局最优解)

这些原则激发了一系列算法的产生,这些算法随后使得信息搜索变得更加高效和可行。在 20 世纪 90 年代末,随着万维网的诞生和快速准确进行互联网搜索的需求,对这些算法的兴趣急剧增长。关于数据,万维网也基于三个技术原则:

  • 分布式数据:数据分布在全球各地,可以从世界各地的任何地方访问

  • 连接数据:数据是相互关联的,而不是孤立的;数据的意义是其与其他数据连接的函数

  • 语义元数据:除了数据本身之外,我们还有关于其关系的信息,并且这些元数据使我们能够高效地搜索

因此,我们开始寻找一种能够尊重这种新型数据本质的技术。自然而然地,我们转向了图形表示。实际上,根据定义,图模型化了不同实体之间的关系。这种方法始于 2012 年,当时 Google 开始为每个搜索的概念添加知识卡片。这些知识卡片可以被视为名称实体的图,其中连接是图链接。这些卡片随后允许进行更相关的搜索和用户便利化。随后,“知识图谱”一词开始指任何通过一系列有意义的连接连接实体的图。这些关系通常表示实体之间的语义关系。

图 7.1 – Google 中的知识卡片

图 7.1 – Google 中的知识卡片

图和知识图谱的正式定义

由于知识图谱是图的一种子类型,我们将从图的简要介绍开始。图是由节点(或顶点)组成的数据结构,这些节点通过关系(或边)连接,以表示一个领域的模型。图可以以紧凑的方式表示知识,同时试图减少噪声。存在不同类型的图:

  • 无向图: 边没有方向

  • 有向图: 边有定义的方向(有明确的开始和结束)

  • 加权图: 边带有权重,表示关系的强度或成本

  • 标记图: 节点与特征和标签相关联

  • 多重图: 同一对节点之间存在多个边(关系)

下图展示了这些图的视觉表示:

图 7.2 – 不同类型的图架构

图 7.2 – 不同类型的图架构

因此,知识图谱是一个具有三个主要属性的子图:

  • 节点代表现实世界实体: 这些实体可以代表人、地点或特定领域的实体(基因、蛋白质、疾病、金融产品等)

  • 关系定义节点之间的语义连接: 例如,两个人可能通过代表友谊的关系相连,或者一个特定的基因与某种特定疾病相关联

  • 节点和边可能具有关联属性: 例如,所有人都会有一个属性,即他们是人类(一个标签),但他们也可以有定量属性(出生日期、特定标识符等)

因此,更正式地说,我们可以认为我们有一个以事实三元组形式表示的知识库(事实数据库)。事实三元组的形式为(头,关系,尾)或(主体,谓词,对象),或者更简洁地,(e1,r1,e2),例如(拿破仑,出生地,阿雅克肖)。知识图谱是这种知识库的表示,它允许我们进行解释。鉴于这些三元组的结构,知识图谱是一个有向图,其中节点是这些实体,边是事实关系。

图 7.3 – 知识库和知识图谱的示例 (https://arxiv.org/pdf/2002.00388)

图 7.3 – 知识库和知识图谱的示例 (arxiv.org/pdf/2002.00388)

知识图谱定义为由一组实体E、关系R和事实F组成的图,其中每个事实f是一个三元组:

G=E,R,F;f=(h,r,t)

如您所见,知识图谱是知识的另一种表示形式。相同类型的数据可以以表格或图的形式表示。我们可以直接从表格中创建三元组,然后直接在知识图谱中表示它们。我们不需要表头,并且更新这种结构更容易。图被认为是通用数据表示,因为它们可以应用于任何类型的数据。实际上,我们不仅可以将表格数据映射到知识图谱,还可以从其他格式(如 JSON、XML、CSV 等)获取数据。图还允许我们灵活地表示递归结构(如树和文档)或循环结构(如社交网络)。此外,如果我们没有所有属性的信息,表格表示将充满缺失值;而在知识图谱中,我们不会遇到这个问题。

图本身代表网络结构。这在许多业务案例(例如,在金融和医学领域)中非常有用,因为这些数据已经以网络的形式结构化。另一个优点是,合并图比合并表格要容易得多。合并表格通常是一个复杂的过程(你必须选择要合并的列,避免创建重复项,以及其他潜在问题)。如果数据以三元组形式存在,合并两个知识图谱数据库就极其简单。例如,看看将这个表格转换为图是多么简单;它们是等价的:

图 7.4 – 表格和图表是等价的

图 7.4 – 表格和图表是等价的

知识图谱不应被视为一个静态实体。实际上,知识是不断演变的;这会导致新的实体或关系被添加。在知识图谱推理(KGR)中最广泛使用的任务之一是预测新的关系。例如,如果 A 是 B 的丈夫和 C 的父亲,这暗示 B 是 C 的母亲,这可以通过逻辑推理得出:(A, husband of, B) ^ (A, father of C) -> (B, mother of, C)。在这个预存数据中,我们推断出一个缺失的关系。

另一个非常重要的任务是,一旦我们获得了新的三元组(这可能需要复杂的预处理),如何更新知识图谱。这非常重要,因为一旦我们整合了一些新的知识,我们就可以进行进一步的分析和推理。此外,作为一个图,我们可以使用图分析算法(如中心性度量、连通性、聚类等)来处理我们的业务案例。利用这些算法使得在知识图谱中进行搜索或复杂查询比在关系数据库中要容易得多。

图 7.5 – 知识图谱是一个动态实体

图 7.5 – 知识图谱是一个动态实体

此外,知识图谱比人们想象的要灵活和适应性强得多。知识图谱可以适应不同的任务。例如,有知识图谱的扩展,如层次知识图谱,其中我们有多级。在层次知识图谱中,一个级别的实体可以连接到下一个级别(例如,当我们有本体时,这非常有用)。实体也可以是多模态的,因此一个节点可以代表一个图像,其他实体(文本或其他图像,或其他类型的模态)与之相连。另一种类型的知识图谱是时序知识图谱,其中我们引入了时间维度。这种类型的知识图谱对于预测分析非常有用。我们可以在以下图中看到这些知识图谱:

图 7.6 – 不同类型的知识图谱

图 7.6 – 不同类型的知识图谱

分类法和本体

图和 KG 之间的主要区别在于,前者是一个给定的结构,表示实体之间的关系,而后者通过允许推理和推理使语义关系明确,对人类和机器都是如此。因此,KG 的优势在于我们可以使用图算法和特定的推理算法(我们将在“理解图推理”部分中稍后详细说明)。通过整合元数据,这些能力得到了增强。实际上,我们可以构建dog和cat实体可能被分组在mammals下)。此外,如果需要,可以整合多个分类法(因此拥有多个树,以便进行更精细的搜索)。这些分类法有助于搜索或在我们需要过滤和操作非常大的 KG 时。例如,maximum_speed属性为100 km,因此鲍勃将无法在不到一个小时的时间内到达那里,因为他的工作有一个distance_from_home属性为120 km)。规则使我们能够改进搜索并解决以前过于复杂的任务(例如,我们可以为关系分配不同的属性:如果married_to是传递性的,我们可以在没有指定关系的情况下自动推断有关某人的信息)。多亏了本体,我们可以有效地快速进行某些类型的推理,例如演绎推理、类推理、传递推理等。

本体通常分为两组:

  • 独立于领域的本体:这些本体提供的是与特定领域无关的基本概念。它们提供了一个高级视图,有助于数据集成,尤其是在存在多个领域的情况下。通常,这些本体数量较少,它们代表第一级,并且是首先构建的。

  • 领域本体:这些本体专注于一个领域,用于提供基本术语。它们对于医学和金融等专业化领域非常有用。它们通常位于独立于领域的本体之下,并且是它的子类。

在本节中,我们看到了 KG 是如何作为灵活的系统来存储数据并能轻松找到知识的。这种灵活性使它们成为后续分析的有力工具,但同时也使得构建它们并不容易。在下一节中,我们将看到如何从一组文本中构建 KG。

使用你的大型语言模型(LLM)创建知识图谱

KG 的构建通常是一个多步骤的过程,包括以下步骤:

  1. 知识创造:第一步,我们定义这个知识图谱(KG)的目的,即收集提取知识的来源。在这个步骤中,我们必须决定如何构建我们的 KG 以及在哪里维护它。一旦构建完成,KG 就必须被存储,并且我们必须有一个高效的查询结构。

  2. 知识评估:在这个步骤中,我们评估获得的 KG 的质量。

  3. 知识清洗:有多个步骤和程序来确保没有错误,然后进行纠正。这一步可以与知识评估同时进行,并且一些流程将它们一起进行。

  4. 知识增强:这涉及一系列步骤来识别知识中是否存在空白。我们还可以整合额外的来源(从其他数据集中提取信息、整合数据库或合并多个知识图谱)。

  5. 知识部署:在这一最终步骤中,知识图谱可以作为独立的应用程序(例如,作为图数据库)部署,或者用于其他应用程序中。

我们可以在以下图中看到这个过程:

图 7.7 – 知识图谱构建流程

图 7.7 – 知识图谱构建流程

知识创建

通常,从头开始构建知识图谱时,本体定义是第一步。有关于如何构建它们的几个指南(包括库和可视化工具)。努力构建清晰、可验证和可重用的本体。定义本体时应有一个目的,与各种利益相关者讨论知识图谱的目的,然后相应地定义本体。最相关的本体应该被选择(知识图谱的第一级),然后定义层次结构和属性。有两种方法:自上而下(首先定义核心本体,然后是更专业的本体)或自下而上(首先定义专业本体,然后将它们分组到超类中)。特别是对于专业领域,我们可以从已经构建的本体开始(有几种是为金融、医学和学术研究定义的),这确保了更好的互操作性。

下一步是从我们的来源中提取知识。在这个步骤中,我们必须从文本语料库或其他来源(数据库、结构化和非结构化数据)中提取三元组(或一组事实)。可以定义两个任务:

  • 命名实体识别(NER):NER 是从文本中提取实体并将它们分类的任务

  • 关系抽取(RE):RE 是识别上下文中各种实体之间联系的任务

NER 是自然语言处理(NLP)中最常见的任务之一,不仅用于知识图谱的创建,而且在我们想要从非结构化文本转换为结构化数据时也是一个关键步骤。它通常需要一个由多个步骤组成的管道(文本预处理、实体识别和分类、上下文分析以及数据后处理)。在 NER 过程中,我们首先进行预处理步骤以避免管道中的错误(例如,正确的标记化),然后尝试识别实体。一旦识别出实体,它们通常会被分类(例如,通过添加如人物、组织或地点等标签)。此外,还尝试使用周围文本来消除歧义(例如,试图识别文本中的Apple代表的是水果还是公司)。然后进行预处理步骤以解决歧义或合并多标记实体。

图 7.8 – NER 示例 (https://arxiv.org/pdf/2401.10825)

图 7.8 – NER 示例 (arxiv.org/pdf/2401.10825)

RE 是我们理解各种提取实体之间关系的任务。更正式地说,我们使用一个模型来识别和分类文本中实体之间的连接(例如,在句子Bob works at Apple中,我们提取关系works at)。它可以被视为一个单独的任务,或者在某些情况下与 NER 一起进行(例如,使用单个模型)。此外,RE 是知识图谱创建的关键步骤,同时对于其他几个 NLP 任务(如问答、信息检索等)也很有用。

有几种方法可以进行 NER 和 RE。最早且最费力的方法是基于知识或基于规则的。例如,在财务文件中识别公司名称的最简单方法之一是使用诸如大写字母等指标(识别Mr.和Ms.元素以提取人物,等等)。基于规则的方法在标准化文档(如临床笔记或官方文件)中效果很好,但可扩展性较差。这些方法需要建立繁琐的上游规则和特定知识,风险是错过不同数据集中许多实体。

基于隐马尔可夫模型、条件随机字段或最大熵(基于从训练数据中学习到的可能性预测实体的方法)的统计方法,使得更大的可扩展性成为可能。然而,这些方法需要大量、高质量的已定义标签的数据集。其他监督学习算法已被用于预测实体然后提取它们。这些算法在高计算成本和特别需要标签的情况下表现良好。获取标签是昂贵的,这些数据集很快就会过时(新公司、新产品等不断出现)。

最近,鉴于无监督学习(如 transformer 模型)的进步,决定使用 LLM 进行 NER 和 RE 以及构建 KG(在某些研究中,这些被称为LLM 增强的 KG)。处理大量文本语料库的能力、在预训练期间获得的知识以及它们的通用性使 LLM 在构建 KG(以及我们稍后将看到的其他相关任务)中变得非常有用。

由于它们能够利用上下文信息和语言能力,最先进的方法通常使用基于 transformer 的模型进行 NER 任务。以前的方法在处理具有复杂结构的文本(属于多个实体的标记,或文本中不连续的实体)时存在问题,而 transformer 在这些情况下表现更优。以前曾使用基于 BERT 的模型,这些模型后来被微调用于不同的任务。然而,如今,我们利用 LLM 的能力,它不需要微调,但可以通过上下文学习来学习任务。然后 LLM 可以直接从文本中提取实体,无需标签,并以所需格式提供它们(例如,我们可能希望 LLM 提供三元组列表或三元组加上给定的标签)。为了避免歧义问题,我们可以要求 LLM 在提取时提供额外的信息。例如,在音乐领域,Apple可以指苹果音乐、英国迷幻摇滚乐队 Apple 或歌手 Fiona Apple。LLM 可以帮助我们根据时期上下文区分这些实体中它指的是哪一个。同时,LLM 的灵活性允许我们在提取过程中将实体与各种本体联系起来。

类似地,LLM 也可以帮助进行 RE 任务。有几种方法可以实现这一点。其中最简单的一种是进行句子级别的 RE,即你向模型提供一个句子,它必须提取两个实体之间的关系。这种方法的扩展是在整个文档级别提取实体之间的所有关系。由于这并非易事,因此可以使用更复杂的、包含多个 LLM 的方法来确保我们能够理解文档的局部和全局关系(例如,在文档中,两个实体之间的局部关系位于同一句子中,但我们也可以有全局关系,其中一个实体位于文档的开头,而另一个实体位于文档的结尾)。

图 7.9 – 基于 LLM 的知识图谱构建的一般框架(此信息来源于 2023 年发表的一篇文章;https://arxiv.org/pdf/2306.08302)

图 7.9 – 基于 LLM 的知识图谱构建的一般框架(此信息来源于 2023 年发表的一篇文章;arxiv.org/pdf/2306.08302)

如前所述,两个任务不需要分别进行(NER 和 RE),但 LLM 提供了在单步中执行它们的灵活性。在这种情况下,定义正确的提示非常重要,其中我们指导模型提取实体和关系,并指定我们想要的输出格式。然后我们可以迭代地进行,从大量文本中提取实体和关系。或者,我们可以使用一组针对不同任务的提示(一个用于实体提取,一个用于关系提取等)并使用 LLM 自动扫描语料库和这些提示。在某些方法中,为了保持更大的灵活性,使用一个 LLM 进行提取,然后使用一个更小的 LLM 进行校对。

另一个有趣的视角是,一个 LLM 就足以创建一个 KG。实际上,LLMs 是用大量文本训练的(最新的 LLMs 使用了包含从互联网抓取和数千本书的万亿个标记进行训练)。今天,有几项研究表明,即使是小型 LLMs(大约 70 亿个参数)也具有相当的知识,特别是关于事实(在 LLM 中的知识定义也很复杂,因为它不是与单个参数相关联,而是广泛分布的)。因此,一些作者提出了直接从 LLM 中蒸馏知识。在这种情况下,通过利用为任务构建的提示,我们进行所谓的 LLM 知识搜索以提取三元组。通过这种方式,直接从 LLM 中提取事实,然后我们可以直接构建我们的 KG。以这种方式构建的 KG 在质量、多样性和新颖性方面与使用大型文本数据集构建的 KG 具有竞争力。

图 7.10 – 从 LLM 中蒸馏 KG 的一般框架 (https://arxiv.org/pdf/2306.08302)

图 7.10 – 从 LLM 中蒸馏 KG 的一般框架 (arxiv.org/pdf/2306.08302)

使用 LLM 创建知识图谱

在本教程中,我将使用 Neo4j 和 LangChain 创建一个由 LLM 构建的 KG。LangChain 允许我们高效地使用 LLM 从文本语料库中提取信息,而 Neo4j 是一个用于分析和可视化图的程序。完整的代码在本书的 GitHub 仓库中(github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr7);在这里,我们将描述一般过程和最重要的代码片段。我们可以有两种方法:

  • 自定义方法:LLMs 天生具备完成任务的能力;我们可以利用这些通用能力

  • LangChain 图转换器:如今,有库可以简化工作,只需几行代码就能达到相同的效果

自定义方法简单来说就是定义一个提示,让模型能够理解任务并高效执行。在这种情况下,我们的提示由以下元素构成:

  • 一个清晰的带有项目符号的任务定义。任务描述可以包含模型必须做什么以及不能做什么。

  • 提供额外的上下文,帮助模型更好地理解如何执行任务。由于这些模型是针对对话任务训练的,提供它们关于应该扮演什么角色的信息有助于提高性能。

  • 一些示例来解释如何执行任务。

这种方法建立在我们在 第三章 中学到的知识之上。我们使用的模型是指令微调的(训练用于执行任务),因此提供清晰的指令有助于模型理解任务并执行它。添加一些示例利用了情境学习。使用精心制作的提示使我们能够灵活地调整提示以适应我们的需求:

#Custom method
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="""
    You are a helpful assistant in creates knowledge graphs by Generating Cypher Queries.\n
    Task:
     *  Identify Entities, Relationships and Property Keys from Context.\n
     *  Generate Cypher Query to Create Knowledge Graph from the Entities Relationships and Property Keys discovered.\n
     *  Extract ALL Entities and RelationShips as Possible.\n
     *  Always extract a person Profession as an Entity.\n
     *  Be creative.
     *  Understand hidden relationships from the network.
     Note: Read the Context twice and carefully before generating Cypher Query.\n
     Note: Do not return anything other than the Cypher Query.\n
     Note: Do not include any explanations or apologies in your responses.\n
     Note: Do not hallucinate.\n
     Entities include Person, Place, Product, WorkPlaces, Companies, City, Country, Animals, Tags like peoples Profession and more \n
     Few Shot Prompts:
      Example Context:
       Mary was born in 1995\. She is Friends with Jane and John. Jane is 2 years older than Mary.
       Mary has a dog named Max,and is 3 years old. She is also married to John. Mary is from USA and a Software Engineer.
      Answer:
        MERGE (Mary:Person {name: "Mary", birth_year: 1995})
        MERGE (Jane:Person {name: "Jane", age:1993})
        MERGE (John:Person {name: "John"})
        MERGE (Mary)-[:FRIENDS_WITH]->(Jane)
        MERGE (Mary)-[:FRIENDS_WITH]->(John)
        MERGE (Jane)-[:FRIENDS_WITH]->(Mary)
        MERGE (John)-[:FRIENDS_WITH]->(Mary)
        MERGE (Mary)-[:HAS_DOG]->(Max:Dog {name: "Max", age: 3})
        MERGE (Mary)-[:MARRIED_TO]->(John)
        MERGE (Mary)-[:HAS_PROFESSION]->(SoftwareEngineer:Profession {name: "Software Engineer"})
        MERGE (Mary)-[:FROM]->(USA:Country {name: "USA"})
    """),
    ("human", "Context:{text}"),
])

执行前面的代码应该产生以下结果:

图 7.11 – 结果截图

图 7.11 – 结果截图

结果显示,精心制作的提示如何成功生成三元组(然后我们可以使用这些三元组来构建我们的 KG)。这突出了 LLM 的巨大灵活性。

我们并不总是想要一个定制的解决方案,但可能想要使用一个更成熟的流程。LangChain 只需几行代码就能提供这种能力:

from langchain_core.documents import Document
from langchain_experimental.graph_transformers import LLMGraphTransformer
llm_transformer = LLMGraphTransformer(llm=llm)
documents = [Document(page_content=content)]
graph_documents = llm_transformer.convert_to_graph_documents(documents)

LangChain 以一种已经结构化的格式给我们相同的成果,这简化了我们的工作。

图形可以在 Neo4j 中进行可视化,我们可以在图上工作,进行搜索,选择节点等操作。

图 7.12 – 从 Neo4j 中获取的图形截图

图 7.12 – 从 Neo4j 中获取的图形截图

一旦生成了图形,我们就可以用它来进行查询。显然,我们可以在 Neo4j 中进行这些查询,但也可以在 Python 中进行。例如,LangChain 允许我们对我们的 KG 进行查询:

from langchain.chains import GraphCypherQAChain
graphchain = GraphCypherQAChain.from_llm(
    llm, graph=graph, verbose=True, return_intermediate_steps=True
)
results = graphchain.invoke({"query":"People who have kids"})
print(results["result"])

执行代码后,你应该获得以下结果:

图 7.13 – 查询 KG

图 7.13 – 查询 KG

如我们所见,LangChain 在这种情况下生成相应的 Cypher 查询,然后执行图查询。这样,我们使用一个 LLM 在 Cypher 中生成查询,同时我们也可以直接用自然语言编写。

知识评估

一旦知识图谱(KG)创建完成,就需要检查错误以及 KG 的整体质量。KG 的质量是通过一系列维度(每个维度都有相应的指标)来评估的,这些维度用于监控 KG 在可访问性、表示、上下文和内在质量方面的表现。以下是一些指标:

  • 准确性:这个指标从语法和语义的角度评估准确性。

  • 完整性:这个指标衡量 KG 在某个领域或任务中的知识量。它通常衡量 KG 是否包含一个领域所需的所有实体和关系(有时会与黄金标准 KG 进行比较)。

  • 简洁性:知识图谱允许知识以高效的方式表达,但它们也面临着快速扩展的风险。空白节点(代表匿名或未命名的实体的一种特定类型的节点,在图中需要节点但未精确指示时使用)在创建过程中经常被生成。如果不加注意,就有可能使知识图谱充满空白节点。

  • 时效性:知识也应定期更新,因为知识可能会变化并变得过时。因此,决定更新的频率很重要。

  • 易用性、操作简便性和操作性:知识图谱(KGs)用于搜索或其他任务;目前存在一些度量标准来衡量知识图谱的有用性。实际上,对于一个知识图谱来说,要变得有用,它必须易于访问、能够被操作,并且能够进行研究和更新。

  • 易于理解:由于知识图谱旨在用于代表人类的知识,一些作者提出了衡量知识图谱对人类可解释程度的方法。确实,今天,在人工智能中,对模型的透明度和可解释性的重视程度更高。

  • 安全性、隐私性和可追溯性:目前也存在一些度量标准来控制谁可以访问知识图谱以及它是否能够抵御外部访问。同样,知识也需要被追踪,因为我们需要确保它来自哪个来源。可追溯性还允许我们遵守隐私法规。例如,我们的知识图谱可能包含关于用户的敏感数据,或者来自错误或有问题的文档。可追溯性允许我们纠正这些错误,删除需要删除其数据的用户的数据,等等。

知识清洗

评估了我们的知识图谱的质量后,我们可以看到其中存在错误。一般来说,错误检测和纠正统称为知识清洗。知识图谱中可能发生不同类型的错误:

  • 我们可能存在语法错误的实体或关系

  • 一些错误可能与本体相关(分配给不存在的本体、将它们连接到错误的本体、本体的错误属性等等)

  • 一些可能是语义的,可能更难识别

  • 知识来源的错误也可能导致知识错误(症状 x 不是疾病 y 的症状,人 x 不是公司 y 的首席执行官等等)

有几种方法可以检测这些错误。最简单的方法是统计方法,通过利用概率和统计建模来识别 KG 中的异常值。也有更复杂的变化,利用简单的机器学习模型。这些模型并不特别准确。由于我们可以使用逻辑推理和本体与 KG,因此有基于知识的推理方法来识别异常值(例如,一个人的实例不能也是地点的实例,因此通过利用类似的规则,我们可以识别异常值)。最后,有基于 AI 的方法,也可以使用一个 LLM 来检查错误。LLM 拥有知识和推理技能,因此可以用来验证事实是否正确。例如,如果我们对于某个错误,我们有三元组 (Vienna, CapitalOf, Hungary),LLM 可以识别这个错误)。然后,还有类似的 KG 修正方法。然而,已经建立了几个框架来进行检测和修正。

知识丰富化

知识丰富化(或 KG 补全)通常是下一步。KGs 通常是不完整的,因此可能需要进行几轮 KG 补全和修正。KG 的完整性有时很难定义,并且与领域和应用任务相关。完成 KG 的第一步通常是识别额外的信息来源(例如,对于一个医学 KG,这可能是一个额外的生物医学数据库或额外的科学文章语料库)。通常,在构建 KG 的第一步中,我们只使用一种数据类型(非结构化文本),然后在第二步中扩展提取到其他数据类型(CSV、XML、JSON、图像、PDF 等)。每种数据类型都提出了不同的挑战,因此我们应该修改我们的管道。我们使用的来源越多,KG 清理和对齐任务就越重要。例如,来源越异构,实体解析(在 KG 级别识别重复实体)的重要性就越大。

一个有趣的替代方案是使用一个 LLM(或其他 transformer 模型)来推断知识。例如,已经探索了三种可能的方法:

  • (h,r,t) 被作为一个 transformer 模型输入以预测其存在的概率(0 表示三元组无效,而 1 是一个有效的三元组)。这种方法的变体是从模型中提取最终隐藏状态并训练一个线性分类器以二进制方式预测三元组是否有效。

  • (h,r,?),我们可以尝试填补这个空缺。

  • (h,r) 和 (t)。这样,我们从模型中获得了两种表示(模型的最终隐藏状态被使用)。之后,我们使用评分函数来预测这个三元组是否有效。这种方法确实更准确,但存在组合爆炸的风险。正如你所见,在这个方法中,我们试图计算两个文本表示之间的相似性((h,r) 和 (t) 的表示)。

这些方法实际上与我们之前章节中尝试计算两个句子之间相似性时看到的方法非常相似。

图 7.14 – LLMs 作为 KG 补全的编码器( https://arxiv.org/pdf/2306.08302 )

图 7.14 – LLMs 作为 KG 补全的编码器(arxiv.org/pdf/2306.08302)

或者,可以使用少量示例或其他提示技术,并要求一个 LLM 直接完成它们。此外,这种方法还允许你在提示中提供额外的项目。在以前的方法中,我们只提供了三元组 (h,r,t);通过提示工程,我们还可以提供其他上下文元素(关系描述、实体描述等)或添加指令以更好地完成任务。

图 7.15 – 基于提示的 KG 补全( https://arxiv.org/pdf/2306.08302 )

图 7.15 – 基于提示的 KG 补全(arxiv.org/pdf/2306.08302)

知识托管和部署

最后一步是 KG 的托管和部署。KG 是一组节点和关系,因此我们可以使用图特定的范式来存储数据。当然,托管 KG 并非没有挑战:

  • 大小:KG 越大,其管理就越复杂

  • 数据模型:我们必须选择一个系统,使我们能够最优地访问我们任务所需的信息,因为不同的系统有不同的优缺点

  • 异质性:图可能包含多种模式,这使得存储更加复杂

  • 速度:随着其增长,知识更新的复杂性也随之增加

  • 用户需求:用户可能有异质的需求,这些需求可能相互冲突,需要我们实施规则和约束

  • 部署:系统必须对用户可访问,并允许轻松推理

KG 的存储有不同选择:

  • KG 可以托管在经典的关系数据库(例如,结构化查询语言(SQL)中,实体和关系存储在表中)。然后,可以从这些表中使用投影重建图的关系结构。使用关系数据库存储大型 KG 可能导致大型表不切实际,或者大量具有复杂层次结构的表。

  • 另一种选择是文档模型,其中数据以元组(键值对)的形式存储,然后组织成集合。这种结构在搜索时可能很方便;它是一个允许快速写入的示意图系统,但更新嵌套集合中的知识可能是一场噩梦。

  • 图数据库是针对存储和搜索图以及数据转换进行优化的数据库。图数据模型包含节点和边,并附加了各种元数据。查询语言也适应了这种结构(并且有些类似于 SQL)。图数据库还有允许异构性和支持速度的优势。Neo4j 是最广泛使用的之一,并使用了一种修改后的查询语言(Cypher)。

  • 三元组存储是数据库直接由三元组组成的地方。今天存在一些数据库,它们以三元组的形式保存信息,并允许在数据库中执行查询。通常,这些数据库也具有对本体和进行逻辑推理的原生支持。

托管带来了一系列挑战,选择数据模型时应考虑到后续应用。例如,如果我们的 KG 需要从我们的关系型数据库中检索数据,使用这个系统在集成方面有优势。然而,在这种情况下,我们将为了异构性和速度而牺牲性能。图数据库在处理性能和图的结构的结构性质方面做得更好,但它可能与其他系统组件的集成不佳。无论我们使用什么系统进行存储,我们都可以根据应用构建混合系统,或者创建一个作为数据库之上的层的 KG。

部署是管道中的最后一步。但这并不意味着故事的结束。KG 很容易过时,因此我们需要考虑知识更新或能够处理新应用的管道。同样,新知识的进入意味着我们必须有知识评估的管道(监控 KG 的质量,确保没有错误输入或没有冲突)。某些知识可能过时或需要删除,以解决法律或隐私问题;因此,我们应该有清理 KG 的管道。其他管道应专注于控制系统的访问和安全。

在本节中,我们看到了创建和部署 KG 所需的所有步骤。现在我们有了我们的 KG,我们可以使用它;在下一节中,我们将讨论如何查找信息并将其作为我们 LLM 的上下文。

使用知识图谱和 LLM 检索信息

在前两章中,我们讨论了 RAG 的能力及其在减少 LLM 生成的幻觉中的作用。尽管 RAG 在研究和工业应用中已被广泛使用,但仍存在局限性:

  • 忽略关系:数据库中的文本是相互关联的,而不是孤立的。例如,一个文档被分割成块;因为这些块属于单个文档,它们之间存在语义联系。当无法通过语义相似性捕获时,RAG 无法捕捉结构化的关系知识。一些作者指出,在科学中,一篇文章与先前作品之间存在重要的关系,这些关系通常通过引用网络来突出显示。使用 RAG,我们可以找到与查询相似的文档,但我们无法找到这个引用网络,从而丢失了这些关系信息。

  • 冗余信息:传递给 LLM 的上下文是一系列连接的块。今天,随着 LLM 的发展,我们可以添加越来越多的上下文(模型的上下文长度越来越长),但它们在冗余信息的存在上遇到了困难。我们添加到上下文中的块越多,用于回答查询的冗余或非必要信息就越多。这种冗余信息的存在降低了模型的表现。

  • 缺乏全局信息:RAG 找到一组文档,但无法找到全局信息,因为文档集不能代表全局信息。这是一个问题,尤其是在摘要任务中。

图检索增强生成(GraphRAG)作为一种新的范式出现,试图解决这些挑战。在传统的 RAG 中,我们通过对嵌入向量进行相似性分析来找到文本块。在 GraphRAG 中,我们在知识图谱上进行搜索,并将找到的三元组提供给上下文。因此,主要区别在于,当用户查询到达时,我们在知识图谱中进行搜索,并使用图中包含的信息来回答查询。

图 7.16 – 直接 LLM、RAG 和 GraphRAG 的比较(img/B21257_07_16.jpg)

图 7.16 – 直接 LLM、RAG 和 GraphRAG 的比较(arxiv.org/pdf/2408.08921)

正式来说,我们可以将 GraphRAG 定义为一个利用知识图谱(KG)为语言模型(LLM)提供上下文并生成更好响应的框架。因此,该系统与经典的 RAG 非常相似;为了避免混淆,在此语境中,我们将称之为向量 RAG。在 GraphRAG 中,知识图谱是知识库,从中我们可以找到实体和关系的信息。GraphRAG 由三个主要步骤组成:

  1. 基于图的索引(G-indexing):在这个初始阶段,目标是构建一个图数据库并正确索引它。

  2. q,在自然语言中,我们希望提取一个子图,我们可以用它来正确回答查询。

  3. 图增强生成(G-generation):最后一步是使用找到的知识进行生成。这一步使用一个 LLM 来完成,该 LLM 接收上下文并生成答案。

图 7.17 – 图 RAG 框架在问答任务中的概述 (https://arxiv.org/pdf/2408.08921)

图 7.17 – 图 RAG 框架在问答任务中的概述 (arxiv.org/pdf/2408.08921)

在接下来的小节中,我们将详细讨论每个步骤。

基于图的索引

在第一步,我们需要选择我们的图数据将是什么。通常,使用两种类型的知识图谱:开放的知识图谱或自构建的知识图谱。在前一种情况下,我们可以使用已经可用的知识图谱,并将其适应到我们的 GraphRAG 中。今天,已经建立了许多知识图谱,并且可供使用(例如,Wikidata 是一个收集来自各种维基百科相关项目的数据的知识库)。一些知识图谱专注于特定领域;这些知识图谱对特定领域有更深入的理解(其中一些是开放的且可用的)。或者,你也可以构建自己的知识图谱。

在构建它或在使用它之前,你应该注意索引。适当的索引使我们能够拥有更快、更高效的 GraphRAG。虽然我们可以将知识图谱可视化为一个图,但它仍然存储在数据库中。索引使我们能够访问我们想要找到的信息。因此,存在几种索引类型。例如,我们可以将文本描述与节点、三元组或本体关联起来,然后在搜索中使用这些描述。另一种方式是将图数据转换为向量,并在这些向量空间上进行搜索(嵌入)。我们还可以使用更尊重数据图性质的索引或混合版本。

图 7.18 – 基于图的索引概述 (https://arxiv.org/pdf/2408.08921)

图 7.18 – 基于图的索引概述 (arxiv.org/pdf/2408.08921)

图引导检索

在 GraphRAG 中,检索对于生成高质量响应至关重要(类似于向量 RAG)。对知识图谱的搜索面临两个需要解决的问题:

  • 爆炸性候选子图:随着图的增长,知识图谱中的子图数量呈指数增长。这意味着我们需要高效的算法来探索知识图谱并找到相关的子图。其中一些算法使用启发式方法以提高效率。

  • 相似度测量不足:我们的查询是文本形式,但我们希望在图上执行相似度搜索。这意味着我们的算法必须能够理解文本和结构信息,并且能够成功比较来自不同来源的数据之间的相似度。

我们可以有不同类型的检索器。最简单的是奥巴马实体,在 KG 中,我们取相邻实体,k-hop=1,或者甚至邻居的邻居,k-hop=2,等等)。非参数检索器是最简单且也是最快的系统,但它们在检索准确性方面存在问题(可以通过学习来改进)。有一些机器和深度学习模型是原生在图上训练的。基于 GNN 的检索器是一个例子。图神经网络(GNNs)是原生处理图的神经网络,可以用于图上的许多任务(节点分类、边预测等),因此它们搜索与查询相似的子图。

或者,我们可以使用基于 LLM 的检索器,其中我们有一个基于 transformer 的模型来进行搜索。然后模型处理和解释查询以进行搜索。这些 LLM 中有一些是在文本上训练过的模型,然后进行微调以搜索图。一个优点是 LLM 可以用作代理,并使用不同的工具或函数来搜索图。基于 LLM 的检索器和基于 GNN 的检索器都显著提高了检索精度,但计算成本很高。今天也有使用不同方法(同时使用 GNN 和 LLM,或与 LLM 一起使用启发式方法)的替代方案,或者过程可以是多阶段的(例如,先用 LLM 进行初始搜索,然后细化结果)。

就像为向量 RAG 所做的那样,我们可以添加额外的组件来进行增强。例如,在前一章中,我们看到我们可以重写查询或分解过于复杂的查询。查询修改有助于更好地捕捉查询的含义(因为有时查询没有捕捉到用户意图的隐含含义)。检索也可以是一个灵活的过程。在前一章中,我们看到在简单的 RAG 中,检索只进行了一次,但在高级和模块化 RAG 中建立了检索可以多阶段或迭代的变体。更复杂的变体使过程根据查询自适应,因此对于简单的查询,只进行一次检索,而对于更复杂的查询,可能需要进行多次迭代。同样,检索后获得的结果也可以进行修改。例如,即使在使用 GraphRAG 的情况下,我们也可以对检索到的知识进行压缩。实际上,如果我们进行多个检索阶段,我们可能也会发现冗余信息,因此方便过滤掉不相关信息。

今天,使用 GraphRAG 也有重新排序检索结果的方法。一个例子是对找到的各种子图进行排序,并可能选择前k个子图。

图 7.19 – 基于图的检索的一般架构](https://github.com/OpenDocCN/freelearn-dl-zh/raw/master/docs/bd-ai-agt-llm-rag-kg/img/B21257_07_19.jpg)

图 7.19 – 基于图的检索的一般架构 (arxiv.org/pdf/2408.08921)

与向量 RAG 相比,另一个区别在于我们如何控制搜索粒度。在向量 RAG 中,粒度是通过决定块的大小来控制的。在 GraphRAG 的情况下,我们不进行分块或寻找块。然而,我们可以通过选择我们找到的内容来在检索过程中控制粒度:

  • 节点: 在 GraphRAG 中,我们可以检索单个实体。节点可以与它们关联属性,然后只将实体及其属性添加到上下文中。这对于目标查询可能很有用。

  • 三元组: 通过扩展搜索粒度,我们选择检索三元组(因此不仅包括节点,还包括它们的关系)。当我们不仅对实体本身感兴趣,还对它们的关系感兴趣时,这很有用。

  • 路径: 在这种情况下,我们仍然扩展检索。路径是一系列节点和关系,因此从实体 X 到实体 Y 的路径是连接它们的实体和关系的所有链。显然,不同实体之间存在多条路径,并且随着图的大小增加,这些路径呈指数增长。因此,我们通常定义规则、使用 GNN 或选择最短路径。

  • 子图: 子图可以被定义为 KG 内部节点和关系的子集。提取子图使我们能够回答复杂查询,因为它允许我们分析实体之间的复杂模式和依赖关系。提取子图有几种方法:我们可以使用特定的模式或进行不同路径的合并。

  • 混合粒度: 我们可以同时使用不同的粒度或选择一个自适应系统。

在 GraphRAG 的情况下,平衡粒度和效率很重要。我们不希望用元素填满上下文,以防止后续 LLM 与无关信息作斗争。这也取决于查询的复杂性:对于简单查询,即使低粒度也足够,而对于复杂查询,更高的粒度更有益。自适应方法可以使系统更高效,同时在需要时保持细微差别。

图 7.20 – 不同级别的检索粒度

图 7.20 – 不同级别的检索粒度

一旦找到并清理了知识,我们就可以将其提供给 LLM 以生成对查询的响应。这种知识进入提供给 LLM 的提示中,模型生成响应。或者,这种找到的知识可以用于某些特定任务的模型(例如,一个用于回答多项选择题的 GNN)。主要问题是图具有非欧几里得性质,与文本信息的集成并不理想。为此,可以使用图翻译器将找到的图信息转换成 LLM 更容易理解的信息。这种转换提高了 LLM 理解信息的能力。因此,一旦我们在图形式(节点、关系、路径或子图)中找到信息,我们就将其置于 LLM 的上下文中。有一些替代方案:

  • 图形格式:我们可以在提示中直接添加关系和节点的集合,或者我们可以使用一种图形结构表示形式,如邻接表或边表。后者紧凑地传达了更好的关系结构。另一种想法是节点序列,它是根据预定规则生成的。这是一种紧凑的表示,包含了图中节点的顺序。

  • 自然语言:存在特定的图语言,可以将信息转换成自然语言,这种表示对 LLM 来说更为亲切。在这个过程中,我们将找到的子图转换成描述性形式。可以使用模板将图转换,其中节点和关系被填充。在某些模板中,您可以定义节点的最近邻和最远邻(图中的 1-hop 和 2-hop),或者您可以使用 LLM 将此子图转换成自然语言描述。

  • 语法树:图被展平并表示为语法树。这些树具有层次结构的优势,并保持了图的拓扑顺序。这种方法保持了图的属性,但使信息对 LLM 来说更容易消化。

  • 代码形式:检索到的图可以被转换成标准格式,例如图形标记语言(GraphML)。这些语言专门为图设计,但它们是结构和文本的混合体。

转换仍然存在困难,因为它必须确保结果是简洁且完整的,同时,对 LLM 来说是可理解的。理想情况下,这种表示还应包括图的结构的详细信息。无论检索到的子图是否转换,结果都输入到 LLM 提示中,并生成响应。

图 7.21 – 通过子图转换增强生成 (https://arxiv.org/pdf/2408.08921)

图 7.21 – 通过子图转换增强生成(arxiv.org/pdf/2408.08921)

GraphRAG 应用

GraphRAG 有多个应用。第一个是问答(与 RAG 相同的应用)中,我们提取子图,而 LLM 使用它们进行后续推理和回答。问答的一个子分支是常识推理问答,它通常以多选题的形式出现。对于这个子任务,我们通常不使用 LLM,而是使用 GNN 或其他机器学习(ML)模型。然而,KG(因此也是 GraphRAG)在信息检索方面有广泛的应用,例如,如果我们想研究一些感兴趣实体之间的关系。KG 可以单独用来提取实体之间的关系,但添加 LLM 的生成功能使我们能够更好地探索这些关系和上下文细微差别。这是学术和文献研究的一个吸引因素。事实上,在学术界,一篇文章是由来自不同机构的多个作者共同撰写的。一篇文章建立在先前研究的基础上,因此对于每篇文章,都有一个引用网络。这些结构元素很容易用图来建模。最近发表的一个有趣的应用展示了 Ghafarollahi 等人如何使用多个 KG 智能体来分析已发表的文献并提出新的研究假设。简而言之,他们从一个由 1,000 篇文章构建的 KG 中提取路径或子图,然后一个智能体分析本体,然后从这个本体中生成新的研究假设。在这个有趣的应用中,多个智能体协作以创建新的潜在材料搜索。

图 7.22 – 科学发现辅助的多智能体图推理系统概述 (https://arxiv.org/pdf/2409.05556v1)

图 7.22 – 科学发现辅助的多智能体图推理系统概述 (arxiv.org/pdf/2409.05556v1)

对 GraphRAG 感兴趣的一个原因是,知识图谱过去常用于事实核查(毕竟,知识图谱是一系列事实的集合),因此向大型语言模型(LLM)提供事实应该会减少 LLM 的幻觉。这一特性使其特别适合生物医学应用。事实上,幻觉是医疗决策应用中的一个严重问题。在医学中,如果 RAG 向量可以减少幻觉,它不允许有全面的视角,尤其是在需要概述来回答问题时。因此,Wu 等人建议使用基于 GraphRAG 的方法,称为MedGraphRAG。在这项工作中,他们使用几个医学来源来创建他们的系统,并利用知识图谱的层次性质。他们为他们的知识图谱构建了三个层级。在第一层级,有用户提供的文档(医院的医疗报告)。这一层级的实体随后连接到一个更基础的信息层级。第二层级由医学教科书和科学文章构建。最后,在第三层级,有从标准化和可靠来源获得的明确定义的医学术语和知识关系。利用从这个知识图谱中的检索获得了在主要医学问答基准数据集上的最先进结果。其优势在于,这个系统也优于在医学知识上微调的模型,从而实现了大量的计算节省。

图 7.23 – MedGraphRAG 框架 (https://arxiv.org/pdf/2408.04187)

图 7.23 – MedGraphRAG 框架 (arxiv.org/pdf/2408.04187)

对 GraphRAG 的进一步兴趣源于使用知识图谱(KGs)向用户提出推荐。在电子商务平台上,推荐系统被用来预测用户的未来购买意图,并建议其他感兴趣的产品。因此,有人提出,该系统将新用户与从过去具有相似行为的用户中派生出的子图相匹配,并利用这些信息来预测可能的未来购买并建议合适的产品。此外,这种方法对于法律和金融领域也很有用。在法律领域,案例和司法意见之间存在广泛的引用,法官使用过去的案例和意见来做出新的裁决。给定一个法律案例,GraphRAG 可以建议先前的法律案例并帮助决策。在金融领域,GraphRAG 可能会建议先前的金融交易或客户案例。

最后,到目前为止,我们建议 GraphRAG 和向量 RAG 是相互对立的。实际上,这两个系统都有优点和缺点,因此将它们协同使用会更有用。Sarmah 等人提出了HybridRAG,在该系统中同时使用了 GraphRAG 和向量 RAG。他们的系统在金融响应方面显示出优势。未来,可能会有系统利用这两种方法,并增加一个路由器来选择是否搜索知识图谱或向量数据库。或者,可能会有更复杂的系统用于上下文中的知识融合(特别是如果知识图谱搜索和块提供了一些冗余信息)。

在本节中,我们讨论了如何将 LLM 连接到知识图谱,以及如何使用它来查找丰富 LLM 上下文的信息。在下一节中,我们将讨论 LLMs 和 KGs 协同有用的其他任务。

理解图推理

本节致力于讨论如何解决图数据任务。在本节中,我们将讨论一些用于解决知识图谱上任务的途径:知识图谱嵌入、图神经网络(GNNs)和大型语言模型(LLMs)。知识图谱嵌入和 GNNs 各需要至少一章内容;因此,这些主题超出了本书的范围,但我们相信对这些内容的介绍对实践者是有益的。实际上,嵌入和 GNNs 都可以与 LLMs 和代理协同使用。

有许多任务需要模型理解结构来解决,这些任务统称为图结构理解任务。许多这些任务都是使用专门设计来学习这些任务的算法或模型来解决的。今天,我们正在开发一种新范式,我们试图使用 LLMs 来解决这些任务;我们将在本节末尾深入讨论这一点。任务的例子可能包括度计算(一个节点有多少邻居)、路径搜索(定义两个节点之间的路径,计算哪条是最短路径等)、哈密顿路径(识别一个只访问每个节点一次的路径)、拓扑排序(识别节点是否可以按拓扑顺序访问)以及许多其他任务。其中一些任务很简单(度计算和路径搜索),但其他任务则要复杂得多(拓扑排序和哈密顿路径)。

图 7.24 – 图结构理解任务 (https://arxiv.org/pdf/2404.14809)

图 7.24 – 图结构理解任务 (arxiv.org/pdf/2404.14809)

另一方面,图学习任务要求模型不仅包括图的结构,还包括图的属性(节点、边和图的特征),从而理解图的语义信息。一些任务的例子包括节点分类(根据节点的属性及其邻居的属性进行分类)、图分类(你必须理解整个图才能对其进行分类)、边分类和节点特征解释(解释节点的某个特征)。知识图谱问答(KGQA)是这类任务之一,因为我们需要理解实体和关系的结构和意义来回答问题。一个类似的任务是执行知识图谱查询以生成文本(这也可以被视为一个子任务)。知识图谱嵌入捕获图中的多关系语义和潜在模式,使它们在关系推理和符号链接预测任务(例如 KG 链接预测)中特别有用。另一方面,图神经网络(GNNs)捕获图结构和节点/边特征;这使得它们在需要归纳推理、使用特征或图结构的局部/全局表示(节点或图分类/回归)的任务中表现良好。

图 7.25 – 图学习任务 (https://arxiv.org/pdf/2404.14809)

图 7.25 – 图学习任务 (arxiv.org/pdf/2404.14809)

知识图谱嵌入

知识图谱(KGs)在表示知识方面非常有效,但它们在规模上的操作却很复杂。这在我们对特定任务感兴趣时,例如链接预测和实体分类,会使得它们的使用变得复杂。因此,知识图谱嵌入(KGE)被提出以简化这些任务。我们已经在第一章中讨论了嵌入的概念。嵌入是将数据投影到低维且连续的向量空间中,这在我们的数据具有稀疏表示(如文本和图)时特别有用。对于一个知识图谱,嵌入是将图(节点、边及其特征向量)投影到这个降低的空间中。然后,KGE 模型试图学习一个既保留结构又保留信息的投影,以便它可以用于下游任务。

学习这种表示方法并非易事,已经提出了几种类型的算法。例如,一些 KGEs 试图保留实体之间的关系模式。TransE 是一种将 KGs 嵌入欧几里得空间的方法,其中实体之间的关系是向量。TransE 基于这样的想法,即三元组中连接的两个实体在空间中应该尽可能接近。此外,从三元组 (h, r, t) 中,它试图学习一个空间,其中 h + r ≈ t,从而允许我们进行各种数学运算。RotatE,另一种方法,也试图使用复杂的向量空间来保留其他关系模式(对称性、反对称性、逆运算和组合)。当我们想要回答需要这种对称性概念(婚姻是对称的)或组合(我的侄子是我哥哥的儿子)的问题时,这非常有用。然而,其他方法试图保留结构模式。实际上,较大的 KGs 包含在嵌入过程中丢失的复杂和复合结构。例如,层次结构、链结构和环结构在经典嵌入过程中丢失。当我们想要进行推理或为某些任务提取子图时,这些结构很重要。ATTH(另一种 KG 嵌入方法)使用双曲空间来同时保留层次结构和逻辑模式。然而,其他方法试图模拟实体和关系的不确定性,使诸如链接预测等任务更容易。

图 7.26 – KGs 中三种典型结构的示意图(img/B21257_07_26.jpg)

图 7.26 – KGs 中三种典型结构的示意图(arxiv.org/pdf/2211.03536)

KGEs 已被广泛用于诸如链接预测等任务。在这种情况下,利用小空间试图识别最有可能缺失的链接。同样,连续空间允许模型用于三元分类。进一步的应用是使用学习到的嵌入来构建推荐系统。

图神经网络

在使用图形与 ML 算法原生结合时存在几个挑战。首先,经典的 ML 模型接受的是矩形或网格状的数据,这使得将其应用于图形非直观。此外,对于图形,我们想要使用的信息有:节点、边、全局上下文和连通性。最后一个尤其难以表示,我们通常使用邻接矩阵。这种表示是稀疏的,随着图中节点数量的增加而大幅增长,因此空间效率低下。此外,由于图中没有顺序,我们可以得到几个传递相同信息的邻接矩阵,但可能不会被模型识别。

GNN 是一种深度学习模型,它原生地接受一个图,并在其学习过程中利用其结构。有不同类型的 GNN(在 进一步阅读 部分有一些综述,你可以深入了解这个主题),但在这里我们将关注主要框架:消息传递。大多数 GNN 可以被视为图卷积网络,其中我们为每个节点聚合来自其邻居的信息。GNN 的一个优点是,在训练任务的同时,它还为每个节点学习一个嵌入。在每一步,这个节点嵌入都会用来自邻居的信息进行更新。

消息传递框架在某种程度上与神经网络非常相似,正如我们之前所看到的。在这种情况下,有两个主要步骤:收集各个邻居节点的嵌入,然后跟随一个聚合函数(这取决于不同的架构而不同)和非线性函数。然后,在每一步,我们更新每个节点的嵌入,学习图的新表示。一个经典的 GNN 可以由一系列 GNN 块和一个最终层组成,该层利用学习到的表示来完成任务。这可以写成如下公式:

<mml:math display="block">mml:msubsupmml:mrowmml:mih</mml:mi></mml:mrow>mml:mrowmml:miv</mml:mi></mml:mrow>mml:mrowmml:mo(</mml:mo>mml:mil</mml:mi>mml:mo+</mml:mo>mml:mn1</mml:mn>mml:mo)</mml:mo></mml:mrow></mml:msubsup>mml:mo=</mml:mo>mml:msupmml:mrow<mml:mi mathvariant="bold-italic">W</mml:mi></mml:mrow>mml:mrowmml:mo(</mml:mo>mml:mil</mml:mi>mml:mo+</mml:mo>mml:mn1</mml:mn>mml:mo)</mml:mo></mml:mrow></mml:msup>mml:mo∙</mml:mo>mml:mrowmml:munder<mml:mo stretchy="false">∑</mml:mo>mml:mrowmml:miw</mml:mi>mml:mo∈</mml:mo><mml:mi mathvariant="script">N</mml:mi>mml:mo(</mml:mo>mml:miv</mml:mi>mml:mo)</mml:mo>mml:mo⋃</mml:mo>mml:mo{</mml:mo>mml:miv</mml:mi>mml:mo}</mml:mo></mml:mrow></mml:munder>mml:mrowmml:mfracmml:mrowmml:mn1</mml:mn></mml:mrow>mml:mrowmml:msubmml:mrowmml:mic</mml:mi></mml:mrow>mml:mrowmml:miw</mml:mi>mml:mo,</mml:mo>mml:miv</mml:mi></mml:mrow></mml:msub></mml:mrow></mml:mfrac></mml:mrow></mml:mrow>mml:msubsupmml:mrowmml:mih</mml:mi></mml:mrow>mml:mrowmml:miw</mml:mi></mml:mrow>mml:mrowmml:mo(</mml:mo>mml:mil</mml:mi>mml:mo)</mml:mo></mml:mrow></mml:msubsup></mml:math>

在这里,在第 l+1 层,我们基于之前的嵌入学习一个表示,h。W 是一个特定于层的权重矩阵,v 是一个节点,w 是邻居集合,c 是归一化系数。

图 7.27 – GNNs

图 7.27 – GNNs

在这种情况下,我们假设每个邻居的贡献是相同的。这可能并不成立,因此受到 RNN 和 transformers 的注意力机制的启发,提出了图注意力网络(GATs)。在这种类型的 GNN 中,模型学习为每个邻居学习不同的重要性级别。目前存在几种 GNN 层模型,但基本原理变化不大。

GNNs 已成功应用于多个图任务,但仍存在一些局限性,如难以扩展、批处理问题等。它们也已被应用于知识图谱,但增加了复杂性。

LLM 在知识图谱上的推理

LLM 的优势在于它们不是为特定任务训练的,而是在训练过程中获得了一组广泛技能。此外,LLM 具有可以通过特定方法改进的推理技能。因此,一些研究人员建议使用 LLM 进行图推理。接近 LLM 的主要方法是用提示作为输入。有三种方法:

  • 手动提示:最简单的方法是向 LLM 提供一个提示,要求它们在图上解决一个任务。在提示中,输入图,并可以添加额外信息(例如,如果我们希望 LLM 使用深度优先搜索(DFS)算法来解决任务,我们提供该算法如何工作的简要说明)。这些提示的局限性在于,无法在提示中插入宽图(这是由于 LLM 的上下文长度限制造成的)。

  • 自我提示:LLM 通过持续更新提示来使任务解决更加容易。换句话说,给定一个原始提示,LLM 进行提示更新以更好地定义任务及其解决方式。然后,基于 LLM 的输出,生成一个新的提示并反馈给 LLM。这个过程可以多次进行以优化输出。

  • API 调用提示:这种提示类型受到代理的启发,其中 LLM 被提供一组它可以调用的 API,用于对图或其他外部工具进行推理。

图 7.28 – 将 LLM 应用于图任务的提示方法 (https://arxiv.org/pdf/2404.14809)

图 7.28 – 将 LLM 应用于图任务的提示方法 (arxiv.org/pdf/2404.14809)

寻找复杂提示策略的替代方法是监督微调(SFT)方法。在这种情况下,使用包含图任务及其解决方案的数据集来训练模型,以提高其推理能力。

LLMs(大型语言模型)的另一个有趣方面是它们也可以与其他模型结合使用。这使得它们的特性可以与专门针对某些任务而优化的模型相结合。例如,我们可以将 LLMs 与 GNNs(图神经网络)结合,在这种情况下,LLMs 可以作为 GNNs 的增强器。GNN 在处理图结构方面比 LLM 做得更好,但 LLM 在处理文本属性方面做得更好。然后我们可以利用这两个模型的优势,以获得一个更强的协同模型。LLMs 比其他模型具有更大的语义和句法能力,这使得它们能够创建强大的文本嵌入。然后 LLM 可以生成数值嵌入,这些嵌入随后被 GNN 用作节点特征。例如,我们有一个科学论文之间的引用网络(我们的图中每个节点是一篇论文),我们希望将文章分类到各种主题中。我们可以取每篇文章的摘要,并使用 LLM 创建摘要的嵌入。这些数字向量将成为文章的节点特征。在这个阶段,我们可以训练我们的 GNN,比没有特征时获得更好的结果。或者,如果节点特征是文本的,我们可以使用 LLM 来生成标签。例如,对于我们的文章网络,我们每个节点都有与之关联的文章标题,我们使用 LLM 在零样本设置下生成一组标签。这很有用,因为手动标注很昂贵,所以我们可以更快地获得标签。当我们获得标签后,我们可以在图上训练一个 GNN。或者,我们也可以考虑同时进行 LLM 和 GNN 的微调。

图 7.29 – LLM 和 GNN 协同

图 7.29 – LLM 和 GNN 协同

另一种有趣的方法是图形成推理。一些用于推理的提示技术没有考虑到人类思维不是线性的,因此根据某些观点,这种推理方法可以用图来近似。有两种利用这种想法的方法:

  • 距离 = 60 km,时间 = 1.5 小时,使用速度 = 距离 ÷ 时间,速度 = 40 km/h,边表示每个思想如何导致下一个。这种图结构使模型能够逐步推理,探索替代方案或验证计算。

  • 在图上验证:在这种方法中,我们使用图来验证推理的正确性和一致性。例如,如果不同的路径应该导致一个逻辑结论,它们应该是相同的或相似的。所以,如果有矛盾,这意味着推理是错误的。通常,人们会为一个问题生成几个推理,将它们结构化为一个图,并分析它们以改进最终答案。这种方法需要一个验证者来分析这个图,通常是另一个 LLM。

图 7.30 – 在图上思考和在图上验证( https://arxiv.org/pdf/2404.14809 )

图 7.30 – 在图上思考并在图上验证(arxiv.org/pdf/2404.14809)

在本节中,我们讨论了图和 LLM 之间错综复杂的关系以及它们如何使我们能够解决一些以前使用图 ML 算法执行的任务。在下一节中,我们将讨论一些尚未解决的问题领域的令人兴奋的视角。

知识图谱和 GraphRAG 的持续挑战

KGs 是存储和组织信息的有力媒介,但仍存在局限性和未解决的问题。特别是对于大型 KGs,可扩展性很重要;必须在表达性和计算效率之间取得平衡。此外,构建 KG 需要大量的计算工作(使用 LLM 从大量文本语料库中提取三元组可能很昂贵,并且需要足够的基础设施)。此外,一旦 KG 构建完成,就必须对其进行评估和清理,这也需要一些努力(手动或计算)。此外,KG 的增长也意味着支持访问或使用的基础设施成本的增长。查询大型 KGs 需要拥有优化算法以避免越来越大的延迟时间风险。工业 KGs 可以包含数十亿个实体和关系,代表着复杂和庞大的规模。许多算法是为小型 KGs(多达数千个实体)设计的,因此在大规模 KGs 中的检索仍然具有挑战性。

此外,知识图谱(KGs)众所周知是不完整的,这意味着必须拥有管道来完善 KG。这意味着需要既有添加额外来源的管道,也有更新数据源的管道。大多数数据库都是静态的,因此创建动态系统具有挑战性。这对于在金融等领域充分利用 KG 至关重要,在这些领域,我们希望考虑到市场的快速变化。顺便提一下,KGs 可以是多模态的,但整合这些模式并不容易。虽然添加模态可以显著提高推理过程,对存储知识的细微差别和 KG 的丰富性的理解,但它也显著增加了管理复杂性(需要更多存储,更复杂的管道,更复杂的知识协调等等)。

GraphRAG 是一种相对较新的技术,并且尚未完全优化。一方面,信息检索可以改进,尤其是在用户的文本查询和知识图谱检索之间的转换。随着知识图谱的不断扩大,找到冗余信息并损害生成过程的风险也随之增加。检索之后,我们可能会得到一个很长的上下文,这个上下文被提供给大型语言模型进行生成。为了减少噪声和降低计算量,我们可以压缩上下文,但这会带来信息丢失的风险。目前,无损压缩是一个活跃的研究领域,而现有方法最多只能允许在压缩和信息保留之间进行权衡。目前还缺乏基准标准来评估新的 GraphRAG 方法;这不允许对当前或未来的方法进行轻松比较。GraphRAG 允许考虑实体间关系和结构化知识信息,减少冗余文本信息,并能够再次找到全局信息。然而,与此同时,文本的细微差别却丢失了,GraphRAG 在抽象问答任务或当问题中没有明确提到实体时表现不佳。因此,向量和 GraphRAG(或 HybridRAG)的结合对未来来说是一个令人兴奋的前景。了解这两种技术如何以最佳方式集成仍然很有趣。

重要的一点是,LLM 并没有专门训练用于图任务。正如我们在第三章中提到的(B21257_03.xhtml#_idTextAnchor042),LLM 被训练来预测序列中的下一个单词。通过优化这个简单的目标,它们获得了大部分技能。显然,仅从文本中吸收空间理解是困难的。这意味着 LLM 通常在结构数据上遇到困难。这一点在表格数据中得到了突出,LLM 在理解表格和关系上存在问题。第一个问题是 LLM 在数值表示上遇到困难,因为标记化步骤使得 LLM 难以理解整个数字(缺乏一致的十进制表示,以及数值运算问题)。这随后影响了需要这种数值理解的图任务的执行。对图理解的具体研究表明,LLM 对图结构有基本理解。LLM 以线性形式理解这些图,并且比图的结构拓扑结构更好地理解与节点相关的标签。根据这些研究,LLM 有基本理解,这强烈受到提示设计、提示技术、提供的语义信息和示例存在的影响。下一代多参数 LLM 在解决小图上的简单任务时取得成功,但随着图和任务复杂性的增加,它们的性能迅速下降。这种对结构数据缺乏理解有两个原因。第一个原因是,在用于训练 LLM 的大文本语料库中,没有多少来自图的数据。因此,LLM 只能学习基本的时空关系,因为这些关系在文本中有所描述。因此,在图数据集上进行的 SFT 可以产生比许多更大的模型更好的结果。

图 7.31 – 在图数据上使用 SFT 比大 LLM 对小 LLM 有更好的性能(img/B21257_07_31.jpg)

图 7.31 – 在图数据上使用 SFT 比大 LLM 对小 LLM 有更好的性能(arxiv.org/pdf/2403.04483)

另一方面,第二个原因源于人类理解空间结构良好的原因。人类从他们在外部世界的经验中学习空间关系。大脑创建心理地图,使我们能够在空间中定位自己。这些地图还使我们能够更好地理解抽象的空间概念,如图形。LLM 没有心理地图,也不能有外部世界的经验,这使得它们在理解抽象空间概念方面处于不利地位。

摘要

在第五章和第六章中,主要问题是如何找到信息以及如何使用这些信息来生成对用户问题的答案。动态地查找信息使我们能够减少我们模型的幻觉并保持其知识更新。

在本章中,我们从一个文本语料库开始,创建了一个系统来找到生成答案的最相关信息(朴素 RAG)。接下来,我们创建了一个更复杂的系统,试图提取仅相关的信息,避免冗余信息或噪声。对于一些研究人员来说,文本本质上包含与背景噪声混合的相关信息。重要的是实体及其关系。从这个还原论方法中产生了在知识图谱中表示基本知识的想法。图使我们能够使用算法来搜索信息或探索可能的连接。长期以来,图推理和 LLM 一直在平行轨道上运行,但最近,它们的故事开始交织在一起。我们已经看到了 LLM 和 KG 之间如何以各种方式进行交互。例如,LLM 可以用来提取用于图构建的关系和实体,或者 LLM 可以用来对 KG 进行推理。同样,我们可以使用 KG 来寻找知识并丰富 LLM 的上下文,从而使其能够有效地回答用户问题。

目前,存在一种类似摩尼教式的定义:要么是向量 RAG,要么是 GraphRAG。两者都有优点和缺点,研究趋势指向这两个世界的统一(HybridRAG)。在未来,我们将找到更多将知识图谱和向量结合在一起的高级方法。此外,对于 LLM 的一侧的图结构理解仍然不成熟。随着训练数据集的增长,新一代 LLM 暴露于更多图示例。然而,在抽象概念如图中的空间关系理解,也意味着在具有更大现实相关性的问题中理解它们。因此,这是一个活跃的研究领域,特别是对于必须在太空中互动并使用人工智能的机器人。

进入太空是人工智能的下一个前沿领域之一。太空中的交互带来了独特的挑战,例如平衡探索和开发。在下一章中,我们将更抽象地讨论这一概念。我们将关注强化学习和代理在太空关系中的行为。无论是棋类游戏、视频游戏还是现实世界环境,代理必须学习如何与太空互动以实现目标。在下一章中,我们将探讨如何使代理能够在不失去目标的情况下探索世界。

进一步阅读

第八章:强化学习与 AI 代理

在第 5-7 章中,我们讨论了如何让我们的模型访问外部记忆。这种记忆存储在另一种类型的数据库中(向量或图),通过搜索,我们可以查找回答问题所需的信息。然后,模型将接收到在特定环境中所需的所有信息,然后回答,提供明确和离散的现实世界信息。

然而,正如我们在第七章中稍后看到的,LLMs 对现实世界的知识和理解有限(无论是常识推理还是空间关系)。

人类通过探索学习在空间中移动并与环境互动。在这个过程中,我们通过试错学习,人类知道我们不能触摸火或如何找到回家的路。同样,我们通过与他们的互动学习如何与其他人类建立联系。我们与真实世界的互动使我们能够学习并改变我们的环境。环境通过感知为我们提供信息,我们处理并从中学习这些信息,最终用于改变环境。这是一个循环过程,其中我们感知环境的变化并做出反应。

我们不能仅仅通过读书来学习所有这些技能;这是不可能的。因此,与环境互动对于学习某些技能和知识至关重要。没有这一点,我们将发现很难完成某些任务。所以,我们需要一个系统,允许人工智能通过探索与环境互动和学习。强化学习(RL)是一种范式,它专注于描述智能代理如何在动态环境中采取行动。RL 控制代理的行为,在给定环境中采取哪些行动(以及该环境的状况),以及如何从中学习。

因此,在本章中,我们将讨论 RL。我们将从该主题的一些理论开始。我们将从一个简单的案例开始,其中代理需要理解如何平衡探索与利用,以找到解决问题的获胜策略。一旦定义了基础知识,我们将描述如何使用神经网络作为代理。我们将查看目前用于与环境交互和学习的最流行的一些算法。此外,我们将展示如何使用代理来探索环境(例如训练代理解决视频游戏)。在最后一节中,我们将讨论大型语言模型(LLMs)与 RL 的交集。

在本章中,我们将讨论以下主题:

  • 强化学习简介

  • 深度强化学习

  • LLM 与 RL 模型的交互

技术要求

大部分代码可以在 CPU 上运行,但最好在 GPU 上运行。当我们讨论如何训练一个代理学习如何玩电子游戏时,这一点尤其正确。代码是用 PyTorch 编写的,大部分使用标准库(PyTorch、OpenAI Gym)。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr8。

强化学习简介

在前面的章节中,我们讨论了一个从大量文本中学习的模型。人类——以及越来越多的 AI 代理——通过试错学习得最好。想象一个孩子学习堆叠积木或骑自行车。没有明确的老师指导每一个动作;相反,孩子通过行动、观察结果并调整来学习。这种与环境互动——其中行动导致结果,而这些结果又塑造未来的行为——是我们学习的关键。与被动地从书籍或文本中学习不同,这种学习是有目标的,并且基于经验。为了使机器能够以类似的方式学习,我们需要一种新的方法。这种学习范式被称为强化学习(RL)。

更正式地说,婴儿通过与环境互动,从行为及其效果之间的因果关系中学到东西。孩子的学习不仅仅是探索性的,而是有特定目标的;他们学习必须采取哪些行动才能实现目标。在我们的一生中,我们的学习往往与我们的环境互动以及环境如何对我们的行为做出反应有关。这些概念被视为学习理论和一般智能的基础。

强化学习被定义为机器学习的一个分支,其中系统必须做出决策,以在给定情况下最大化累积奖励。与监督学习(其中模型从标记的例子中学习)或无监督学习(其中模型通过在数据中检测模式来学习)不同,在强化学习中,模型从经验中学习。事实上,系统没有被告知必须执行哪些动作,而是必须探索环境并找出哪些动作可以使它获得奖励。在更复杂的情况下,这些奖励可能不是立即的,而是稍后才会到来(例如,在棋盘上牺牲一个棋子但最终获胜)。因此,在更广泛的意义上,我们可以说强化学习的基本原理是试错和延迟奖励的可能性。

从这个基础上,我们推导出两个重要的概念,这些概念将成为我们讨论强化学习(RL)的基础:

  • 探索与利用:模型必须利用之前获得的知识来实现其目标。同时,它必须探索环境以便在未来做出更好的选择。在这两个方面之间必须取得平衡,因为解决问题可能不是最明显的路径。因此,模型必须在利用最佳行动(利用)之前测试不同类型的行动(探索)。即使今天,选择最佳平衡仍然是强化学习理论的一个开放挑战。理解这一点的有用方法是想象有人在新的城市尝试不同的餐厅。一开始,他们可能会尝试各种地方(探索)以了解有什么可用的。在发现几个喜欢的餐厅后,他们可能会开始更频繁地去同一个地方(利用)。但如果他们总是坚持去熟悉的地方,他们可能会错过发现更好的餐厅的机会。挑战在于知道何时尝试新事物,何时坚持有效的方法——这仍然是强化学习中的一个开放问题。

  • 在不确定的环境中实现全局目标:强化学习专注于实现目标,而不需要将问题重新构造成子问题。相反,它解决了一个经典的监督机器学习挑战,这涉及到将复杂问题分解成一般子问题,并制定一个有效的计划。在强化学习的情况下,另一方面,直接定义一个代理必须解决的问题。这并不意味着必须只有一个代理,但可以有多个具有明确目标的代理相互交互。一个相关的例子是学习在新城市高效通勤。一开始,你不会将任务分解成“学习公交时刻表”、“估计步行时间”或“优化天气暴露”这样的子问题。相反,你将目标视为整体:每天按时到达工作地点。通过试错——尝试不同的路线、尝试火车与公交车的对比、调整交通状况——你学会了哪些选项最有效。随着时间的推移,你制定了一个策略,而无需明确标记问题的每个部分。如果你与室友或朋友住在一起,他们也在做同样的事情,你们可能会交换建议或为了最快的路线而竞争,就像强化学习中的多个代理相互作用一样。

强化学习系统中存在几个元素:一个 代理,一个 环境,一个 状态,一个 策略,一个 奖励信号,和一个 价值函数。代理显然是学习者或决策者(与环境交互、做出决策并采取行动的模型)。另一方面,环境是与环境交互的一切。状态代表在特定时间环境的一个特定条件或配置(例如,在移动之前棋盘上棋子的状态)。给定一个状态,代理必须做出选择并选择一个要采取的动作。并非所有空间总是可观察的;我们的代理只能访问状态的局部描述。例如,在一个迷宫中导航的机器人代理只能通过摄像头获取信息,因此只能观察到它面前的东西。从摄像头获得的信息是观察结果,因此模型将只使用状态的一个子集。

图 8.1 – 强化学习系统中元素的表现

图 8.1 – 强化学习系统中元素的表现

在前面的图中,我们可以看到环境(在这种情况下,游戏屏幕)是如何以向量形式表示的(这就是状态)。此外,三种可能的行为在这个例子中以标量表示。这使我们能够训练一个算法。

动作是代理在环境中可以执行的可能决策或移动(棋盘上的棋子只能向特定方向移动:主教只能斜着走,车可以垂直或水平移动,等等)。动作集可以是离散的(迷宫中的移动)但也可以是连续的动作空间(在这种情况下,它将是实值向量)。这些动作是实现特定目标策略的一部分,根据环境的状态和政策。

图 8.2 – 代理与环境交互选择动作

图 8.2 – 代理与环境交互选择动作

在前面的图中,我们可以看到时间 0 (t0) 对应于状态 t0;如果我们的代理执行一个动作,这将改变环境。在时间 t1,环境将不同,因此我们将拥有不同的状态,t1。

策略定义了代理在特定时间的行为方式。给定环境的状态和可能的行为,策略将行为映射到系统的状态。策略可以是一组规则、查找表、函数或其他东西。策略也可以是随机的,通过为每个行为指定一个概率。从某种意义上说,策略是强化学习的心脏,因为它决定了代理的行为。在心理学中,这可以定义为一系列刺激-反应规则。例如,一个策略可能是每当有机会时吃掉对手的棋子。更常见的是,策略是参数化的:策略的输出是一个可计算的函数,它依赖于一组参数。最广泛使用的系统之一是神经网络,其参数通过优化算法进行优化。

奖励是从环境中接收到的正或负信号。它是一个关键因素,因为它为代理在每个时间步提供了目标。这个奖励被用来定义代理的局部和全局目标。换句话说,在每个时间步,代理从环境中接收一个信号(通常是一个数字),而在长期,代理的目标是优化这个奖励。奖励然后使我们能够确定模型是否表现正确,并使我们能够理解正负事件之间的差异,理解我们与环境的互动以及对于系统状态的适当响应。例如,失去一个棋子可以被视为局部负奖励,而赢得游戏则是全局奖励。奖励通常用于改变策略并对其环境进行校准。

图 8.3 – 正负奖励的示例

图 8.3 – 正负奖励的示例

然而,奖励虽然告诉我们即时什么是正确的,而价值函数则定义了长期的最佳方法。用更技术性的术语来说,状态的价值是一个代理从该状态开始可以期望在未来获得的奖励总量(例如,从该位置开始,代理在游戏中可以收集多少分数)。简单来说,价值函数帮助我们理解如果我们考虑该状态及其后续状态会发生什么,以及未来可能发生什么。然而,奖励和价值之间存在依赖关系;没有前者,我们无法计算后者,尽管我们的真正目标是价值。例如,牺牲一个棋子可能有低奖励,但最终可能是赢得游戏的关键。显然,建立奖励要容易得多,而建立价值函数则很困难,因为我们不仅要考虑当前状态,还要考虑代理所做的所有先前观察。

强化学习的一个经典例子是必须导航迷宫的智能体。状态 S 定义了智能体在迷宫中的位置;这个智能体有一个可能的动作集 A(向东、西、北或南移动)。策略 π 指示智能体在特定状态下必须采取什么动作。奖励 R 可以是当智能体选择不允许的动作时的惩罚(例如撞墙),而价值是走出迷宫。在 图 8**.4 中,我们展示了智能体与其环境之间的交互:

图 8.4 – 强化学习系统概述模型 (https://arxiv.org/pdf/2408.07712)

图 8.4 – 强化学习系统概述模型 (arxiv.org/pdf/2408.07712)

在给定的时间步 (t), 智能体观察到环境的当前状态 (St),根据策略 π 选择动作 (At),并获得奖励 (Rt)。此时,循环在新状态 (St+1*) 上重复。策略可以是静态的,也可以在每个循环结束时更新。

在下一节中,我们将开始讨论强化学习的初始示例,从经典的多臂老丨虎丨机开始。

多臂老丨虎丨机问题

k-armed bandit problem 可能是介绍强化学习最经典的例子。在所有那些模型必须从其动作中学习而不是从正例中接受指导的问题中,都需要强化学习。在 k-armed bandit 问题中,我们有一个具有 n 个独立臂(带枪)的老丨虎丨机,每个带枪都有自己的成功概率分布。每次拉动臂时,我们都有随机概率要么获得奖励要么失败。在每次动作中,我们必须选择拉动哪个杠杆,奖励就是我们获得的。目标是最大化在一定时期内(例如,1,000 个动作或时间步)的期望总奖励。换句话说,我们必须找出哪些杠杆给我们带来最好的回报,并将最大化我们的动作(即,我们将更频繁地拉动它们)。

问题可能看起来很简单,但它远非微不足道。我们的智能体无法访问真正的带枪概率分布,必须通过试错来学习最有利的带枪。此外,尽管这个问题很简单,但它与几个现实世界的案例场景有相似之处:为患者选择最佳治疗方案、A/B 测试、社交媒体影响等等。在每一个时间步 t,我们可以选择一个 At 动作并获得相应的奖励 (Rt)。任意动作 a 的价值,定义为 q⇤**(a),是在时间步 t 选择此动作时的期望奖励:

<mml:math display="block">mml:msubmml:mrowmml:miq</mml:mi></mml:mrow>mml:mrowmml:mi*</mml:mi></mml:mrow></mml:msub><mml:mfenced separators="|">mml:mrowmml:mia</mml:mi></mml:mrow></mml:mfenced>mml:mo=</mml:mo><mml:mi mathvariant="double-struck">E</mml:mi>mml:mo[</mml:mo>mml:msubmml:mrowmml:miR</mml:mi></mml:mrow>mml:mrowmml:mit</mml:mi></mml:mrow></mml:msub>mml:mo|</mml:mo>mml:msubmml:mrowmml:miA</mml:mi></mml:mrow>mml:mrowmml:mit</mml:mi></mml:mrow></mml:msub>mml:mo=</mml:mo>mml:mia</mml:mi>mml:mo]</mml:mo></mml:math>

如果我们知道每个动作的价值,我们实际上已经解决了这个问题(我们会总是选择价值最高的那个)。然而,我们并不知道动作的价值,但我们可以计算一个估计值,定义为 Qt(a),我们希望它接近 q(a)*。在每一步,我们都有估计值 Qt(a),这些值比其他值大;选择这些动作(拉动杠杆)被称为贪婪动作和利用当前知识。相反,选择估计值较低的动作被称为探索(因为它允许我们探索其他动作会发生什么,从而提高我们对这些动作的估计)。

图 8.5 – 多臂老丨虎丨机

图 8.5 – 多臂老丨虎丨机

探索可能会在后续步骤中减少收益,但保证长期收益更大。这是因为我们的估计可能不正确。探索允许我们纠正动作的估计值。特别是在早期步骤中,探索更为重要,以便系统可以了解哪些动作最好。在最后一步,模型应该利用最好的动作。为此,我们需要一个系统,允许我们平衡探索和利用。

为了得到价值的初始估计,我们可以取收到的奖励的平均值:

Qta=sumofrewardswhentheactionaistakenpriortotimesteptnumberoftimestheactionaistakenpriortotimestept=∑i=1t−1Ri·1{Ai=a}∑i=1t−11{Ai=a}

在这个简单方程中,1代表一个变量,表示在时间步长中是否使用了动作(使用时为 1,未使用时为 0)。

1{Ai=a}=1ifactionaistakenattimestepi0otherwise

如果动作从未被使用过,分母将为零;为了避免结果为无穷大,我们使用默认值(例如,0)。如果步数趋于无穷大,估计值应收敛到真实值。一旦获得这些估计值,我们就可以选择动作。选择动作最简单的方法是选择最大值(贪婪动作)。arg max函数正是如此:

At=argmaxaQta

正如我们之前所说的,我们并不总是想选择贪婪动作,但我们希望模型也能探索其他动作。为此,我们可以引入一个概率 ε,这样智能体将以相等的概率从其他动作中选择。简单来说,模型几乎总是选择贪婪动作,但以概率 ε 选择其他动作(无论其值如何)。通过增加步骤数,其他动作也将被测试(在无限大时,它们将被测试无限多次),确保 Q 收敛到 q*。同样,选择最佳动作的概率收敛到 1 - ε。这种方法被称为 ε-greedy 方法,它允许在利用和探索之间进行一些平衡。

举一个简单的例子,我们可以想象一个有 10 个臂的老丨虎丨机(k=10),其中我们有一个动作值 q,我们有一个正态分布来表示每个动作的真实值。在这里,我们绘制了 1,000 个示例:

图 8.6 – 动作值分布

图 8.6 – 动作值分布

在以下示例中,我们比较了不同的 ε-贪婪方法。奖励随着智能体经验的增加而增加,然后达到平台期。与允许探索的方法相比,纯贪婪方法次优。同样,选择一个过高的 ε 常数(ε=0.5)会导致比纯贪婪方法更差的结果。

图 8.7 – 不同贪婪方法的时间步平均奖励

图 8.7 – 不同贪婪方法的时间步平均奖励

为了研究这种现象,我们可以查看智能体的最优选择(图 8**.8)。

图 8.8 – 不同贪婪方法的时间步最优选择百分比

图 8.8 – 不同贪婪方法的时间步最优选择百分比

贪婪方法只有三分之一的时间选择最优选择,而包含一些探索的方法有 80%的时间(ε=0.1)%选择最优选择。这个结果表明,能够探索环境的智能体可以达到更好的结果(可以识别最优动作),而长期贪婪的智能体会选择次优动作。此外,ε-贪婪方法比贪婪方法更快地找到最优动作。

在这个例子中,我们探索了简单的方法,其中 ε 是常数。在某些变体中,ε 随着步骤数的增加而减少,允许智能体在环境被充分探索后从探索转移到利用。ε-greedy 方法在几乎所有情况下都表现最佳,尤其是在存在更大的不确定性(例如,更大的方差)或系统非平稳时。

到目前为止,我们看到的系统在样本数量较多时并不高效。因此,我们不是取观察到的奖励的平均值,而是可以使用一种逐步方法(目前最广泛使用的方法)。对于一个被选择i次的动作,奖励将是Ri,我们可以计算估计值Qn如下:

Qn=R1+R2+⋯+Rnn−1

在这一点上,我们不必每次都重新收集平均值,而是可以记录计算结果,并以这种方式逐步进行更新:

<mml:math display="block">mml:msubmml:mrowmml:miQ</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi>mml:mo+</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:msub>mml:mo=</mml:mo>mml:msubmml:mrowmml:miQ</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:msub>mml:mo+</mml:mo>mml:mfracmml:mrowmml:mn1</mml:mn></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:mfrac>mml:mo[</mml:mo>mml:msubmml:mrowmml:miR</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:msub>mml:mo-</mml:mo>mml:msubmml:mrowmml:miQ</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:msub>mml:mo]</mml:mo></mml:math>

这可以简单地看作是一种逐步调整期望值:

Estimatednew←Estimatednew+step_size[Target−Estimatedold]

实际上,我们可以将[目标 - 估计旧值]视为一种我们在尝试逐步纠正并使其接近真实目标的估计误差。智能体试图将价值估计移动到真实值。

我们可以测试这种逐步实现,并看到在初始的探索阶段之后,智能体开始利用最优选择:

图 8.9 – 逐步实现

图 8.9 – 逐步实现

1/n可以被替换为一个固定的步长参数α。

<mml:math display="block">mml:msubmml:mrowmml:miQ</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi>mml:mo+</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:msub>mml:mo=</mml:mo>mml:msubmml:mrowmml:miQ</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:msub>mml:mo+</mml:mo>mml:miα</mml:mi>mml:mo[</mml:mo>mml:msubmml:mrowmml:miR</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:msub>mml:mo-</mml:mo>mml:msubmml:mrowmml:miQ</mml:mi></mml:mrow>mml:mrowmml:min</mml:mi></mml:mrow></mml:msub>mml:mo]</mml:mo></mml:math>

使用α不仅简化了计算,还减少了这种方法固有的偏差。实际上,对于动作的初始值估计Q1(a),的选择可以显著影响早期决策和收敛行为。α还允许你更好地处理非平稳问题(其中奖励概率随时间变化)。初始期望值通常设置为 0,但可以选择大于 0 的值。这种替代方案称为乐观贪婪策略;这些乐观值刺激智能体更多地探索环境(即使我们使用ε=0 的纯贪婪方法)。缺点是我们必须测试不同的初始Q值,而在实践中,几乎所有从业者都将其设置为 0 以方便。

通过测试乐观贪婪方法,我们可以看到它的行为与ε-贪婪方法相似:

图 8.10 – 乐观贪婪与ε-贪婪方法的比较

图 8.10 – 乐观贪婪与ε-贪婪方法的比较

在非平稳问题中,α可以设置为给予近期奖励比先前奖励更大的权重。

最后一点:到目前为止,我们选择了具有更高估计值的贪婪动作。相比之下,我们随机选择非贪婪动作。我们不仅可以随机选择它们,还可以根据它们的潜在最优性和不确定性来选择。这种方法称为上置信界(UCB),其中动作A的选择基于:

At=argmaxa[Qta+clntNt(a)]

其中 ln(t) 代表 t 的自然对数,c> 0 控制探索,而 Nt 是动作 A 被测试的次数。这种方法意味着所有动作都将被测试,但那些估计值较低(并且已被频繁测试)的动作将以递减的方式再次被选择。想象一下在挑选不同的餐厅。UCB 帮助你在去你已经喜欢的餐厅(高估计值)和尝试可能更好但尚未访问过的餐厅(高不确定性)之间取得平衡。随着时间的推移,它自然会减少对表现不佳的选项的探索,同时继续测试那些尚未充分探索但可能很好的选项。UCB 工作得非常好,尽管它在除了多臂老丨虎丨机以外的其他方法中很难应用。

如您所见,UCB 通常给出更好的结果:

图 8.11 – UCB 对贪婪方法的改进

图 8.11 – UCB 对贪婪方法的改进

多臂老丨虎丨机是强化学习的一个经典例子,但它允许人们开始理解强化学习是如何工作的。

多臂老丨虎丨机已被用于多个应用,但它是一个过于简化的系统,不能应用于不同的现实世界情况。例如,在棋局中,目标不是吃掉棋子,而是赢得比赛。因此,在下一小节中,我们将开始探讨考虑比即时收益更早目的的方法。

马尔可夫决策过程

马尔可夫决策过程(MDPs)是动作不仅影响即时奖励,还影响未来结果的问题。在 MDPs 中,延迟奖励比我们在多臂老丨虎丨机问题中看到的权重更大,而且在决定不同情况下的适当动作时也是如此。

想象你正在穿越迷宫。你进入的每个交叉点或走廊都是一个状态,你做出的每个转弯都是一个改变你状态的行动。一些路径会带你更接近出口(最终奖励),而其他路径可能会让你绕圈子或走到死胡同。每一步的奖励可能不是即时的——你只有在到达终点时才会得到大奖励。因此,你采取的每个行动都需要考虑它如何影响你后来达到目标的机会。

在马尔可夫决策过程(MDP)中,这个想法被形式化:智能体必须在每个状态下决定最佳动作,而不仅仅是即时奖励,还要最大化长期成功,这使得它们比像多臂老丨虎丨机这样的简单问题更复杂,在多臂老丨虎丨机问题中,只考虑即时奖励。

之前我们只是估计 q(a)。现在,我们想要在状态 s 的存在下估计动作 a 的价值,即 q(s,a)。在每个时间步,智能体接收环境的表示 St 并执行动作 At,获得奖励 R,并移动到新的状态 St+1*。可以看出,智能体的动作可以改变环境的状态。

在有限的 MDP 中,状态、动作和奖励的集合包含有限数量的元素。变量 R 和 S 是依赖于先前状态和动作的概率分布。我们可以使用状态转移概率函数 p(s’, r | s, a) 来描述这个系统的动力学:

ps′,r|s,a=PrSt=s′,Rt=rSt−1=s,At−1=a}

换句话说,状态和奖励取决于先前的状态和动作。在每一步,新的状态和奖励将来自前一个周期。这将重复有限的一系列事件。因此,每个状态将总结所有先前信息(例如,在井字棋中,新的系统配置给我们关于先前移动的信息),并被称为马尔可夫状态,具有马尔可夫属性。马尔可夫状态的优势在于每个状态都包含我们预测未来的所有所需信息。前面的函数描述了当我们执行动作时,一个状态如何演变到另一个状态。遵循此属性的 RL 问题被称为 MDP。因此,从这个函数中,我们可以推导出关于环境的任何我们关心的事情。然后我们可以推导出状态转移概率:

ps′|s,a=PrSt=s′St−1=s,At−1=a}=∑r∈Rps′,r|s,a

我们还可以推导出状态-动作对的预期奖励:

<mml:math display="block">mml:mir</mml:mi><mml:mfenced separators="|">mml:mrowmml:mis</mml:mi>mml:mo,</mml:mo>mml:mia</mml:mi></mml:mrow></mml:mfenced>mml:mo=</mml:mo><mml:mi mathvariant="double-struck">E</mml:mi><mml:mfenced close="]" open="[" separators="|">mml:mrowmml:msubmml:mrowmml:miR</mml:mi></mml:mrow>mml:mrowmml:mit</mml:mi></mml:mrow></mml:msub></mml:mrow>mml:mrowmml:msubmml:mrowmml:miS</mml:mi></mml:mrow>mml:mrowmml:mit</mml:mi>mml:mo-</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:msub>mml:mo=</mml:mo>mml:mis</mml:mi>mml:mo,</mml:mo>mml:msubmml:mrowmml:miA</mml:mi></mml:mrow>mml:mrowmml:mit</mml:mi>mml:mo-</mml:mo>mml:mn1</mml:mn></mml:mrow></mml:msub>mml:mo=</mml:mo>mml:mia</mml:mi></mml:mrow></mml:mfenced>mml:mo=</mml:mo>mml:mrowmml:munder<mml:mo stretchy="false">∑</mml:mo>mml:mrowmml:mir</mml:mi>mml:mo∈</mml:mo>mml:miR</mml:mi></mml:mrow></mml:munder>mml:mrowmml:mir</mml:mi></mml:mrow></mml:mrow>mml:mrowmml:munder<mml:mo stretchy="false">∑</mml:mo>mml:mrowmml:mis</mml:mi>mml:mo∈</mml:mo>mml:miS</mml:mi></mml:mrow></mml:munder>mml:mrowmml:mip</mml:mi><mml:mfenced separators="|">mml:mrowmml:msupmml:mrowmml:mis</mml:mi></mml:mrow>mml:mrowmml:mi'</mml:mi></mml:mrow></mml:msup>mml:mo,</mml:mo>mml:mir</mml:mi></mml:mrow>mml:mrowmml:mis</mml:mi>mml:mo,</mml:mi>a</mml:mi></mml:mrow></mml:mfenced></mml:mrow></mml:mrow></mml:math>

我们可以推导出状态-动作-下一个状态三元组的期望奖励:

rs,a,sʹ=ERt|St−1=s,At−1=a</mml:mi>,St=s′=∑r∈</mml:mi>R</mml:mi>rps′,r|s,aps′|s,a

这展示了该框架的灵活性。简而言之,t 不一定是时间步,而是一系列状态(一系列决策、机器人的移动等),这使得 MDP 成为一个灵活的系统。毕竟,在 MDP 中,每个问题都可以归结为三个信号:动作、状态和奖励。这使我们能够更好地抽象化,以表示以目标为导向的学习。

对于一个智能体来说,其目标显然是在长时间内最大化累积奖励(而不是立即收益)。这个系统已被证明非常灵活,因为许多问题都可以用这种方式形式化(只需要找到一种定义奖励的方法,以便智能体学会如何最大化它们)。有一点需要注意的是,智能体会尝试以任何可能的方式最大化奖励;如果目标定义不明确,可能会导致意想不到的结果(例如,在棋类游戏中,目标是赢得游戏;如果奖励是吃掉一个棋子而不是赢得游戏,那么智能体将尝试最大化吃掉的棋子数量,即使这可能导致输掉游戏)。

这可以更正式地表达,其中G是从步骤t开始并在此之后收到的累积奖励总和:

<mrow><mrow><msub><mi>G</mi><mi>t</mi></msub><mo>=</mo><msub><mi>R</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>+</mo><msub><mi>R</mi><mrow><mi>t</mi><mo>+</mo><mn>2</mn></mrow></msub><mo>+</mo><mo>…</mo><mo>+</mo><msub><mi>R</mi><mi>T</mi></msub></mrow></mrow>

因此,我们的目标是最大化G。对于有明确结束的序列来说,这更容易定义(例如,只能进行有限次移动的游戏)。一系列定义明确的步骤被称为一个回合,最后一个状态被称为终止状态。请注意,每个回合都是相互独立的(输掉一局不会影响下一局的结果)。当然,这并不总是可能的;还有一些明确的连续任务,其中没有净结束(例如,在环境中移动的机器人),对于这些任务,前面的方程不适用。在这种情况下,我们可以使用所谓的折现率γ。这个参数允许我们决定智能体的行为:当γ接近 0 时,智能体将尝试最大化即时奖励,而当γ接近 1 时,智能体将更加重视未来的奖励:

<mrow><mrow><msub><mi>G</mi><mi>t</mi></msub><mo>=</mo><msub><mi>R</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>+</mo><mi>γ</mi><msub><mi>R</mi><mrow><mi>t</mi><mo>+</mo><mn>2</mn></mrow></msub><mo>+</mo><msup><mi>γ</mi><mn>2</mn></msup><msub><mi>R</mi><mrow><mi>t</mi><mo>+</mo><mn>3</mn></mrow></msub><mo>+</mo><mo>…</mo><mo>=</mo><mrow><munderover><mo>∑</mo><mrow><mi>k</mi><mo>=</mo><mn>0</mn></mrow><mi mathvariant="normal">∞</mi></munderover><mrow><msup><mi>γ</mi><mi>k</mi></msup><msub><mi>R</mi><mrow><mi>t</mi><mo>+</mo><mi>k</mi><mo>+</mo><mn>1</mn></mrow></msub></mrow></mrow></mrow></mrow>

正如我们在多臂老丨虎丨机问题部分所看到的,我们可以估计价值函数(一个智能体处于某个状态的好坏)。考虑策略π,状态S的价值是从S开始并遵循策略π的期望回报:

vπs=EπGt|St=s=Eπ∑k=0∞γkRt+k+1|St=sforalls∈S

这被称为策略 π 的状态-价值函数,Gt 是期望回报。同样,我们可以在策略 π 下定义在状态 S 中采取动作 A 的价值:

qπs,a=EπGt|St=s,At=a=Eπ∑k=0∞γkRt+k+1|St=s,At=a

这被称为策略 π 的动作-价值函数。我们可以通过经验(与环境交互)来估计这些函数,并且在无限远处,它们应该接近真实值。这种进行许多实际回报随机样本平均的方法被称为蒙特卡洛方法。

为了提高效率,我们可以将其重写为递归形式(使用折现):

vπs=EπGt|St=s=EπRt+1+γGt+1|St=s=∑aπ(a|s)∑s′,rps′,r|s,ar+γvπs′foralls∈S

这种简化的形式被称为 Bellman 方程。这可以表示为从上一个状态向前思考下一个状态。从一个具有策略的状态,我们选择一个动作,并按照给定的概率获得奖励(或不获得)。Bellman 方程对这些概率进行平均,给它们发生的可能性赋予权重。这个方程是许多优秀强化学习算法的基础。

![图 8.12 – Bellman 回退图

图 8.12 – Bellman 回退图

现在我们既有状态值函数 vπ(s) 和动作值函数 qπ(s, a),我们可以评估策略并选择最好的策略。动作值函数允许我们根据状态选择最佳动作。例如,考虑德克萨斯扑克游戏的情况。一个玩家有 100 美元,必须从状态 π 出发选择策略。策略 π1 的状态值函数返回 10,而 π2 的回报为 -2。这意味着第一个策略带来期望收益 10,而 π2 带来期望损失 2。给定一个状态 s,玩家想要弄清楚选择哪个动作。例如,选择是否下注 10 或 5,qπ (s, a) 告诉我们从这个动作中期望累积奖励是多少。因此,前面的方程使我们能够确定选择哪个动作或策略以最大化奖励。

从图 8.12可以理解,解决强化学习任务意味着找到一种最优策略,在长期内成功收集到许多奖励。对于马尔可夫决策过程(MDPs),我们可以定义一个最优策略,因为我们可以在所有状态下评估一个策略是否比另一个策略更好,如果它对所有状态的预期回报更高。*π** 表示最优策略,它是所有可能策略中具有最大值函数的那个:

v*s=maxπvπsforall<mi}s∈S

最优策略共享相同的最佳动作值函数 q*,它被定义为所有可能策略中最大动作值函数:

q*s,a=maxπqπs,aforall<mi}s∈S

这两个函数之间的关系可以总结如下:

qs,a=ERt+1+γv(St+1)|St=s,At=a

该方程表示给定一个状态-动作对时的累积回报。然而,在强化学习(RL)中,最优值函数是一个理想的状态,但找到最优策略尤其困难,尤其是在任务复杂或计算成本高昂时。因此,强化学习试图通过使用动态规划(DP)等方法来近似它们。动态规划的目的就是利用值函数来寻找好的策略(即使不是精确解)。在这个阶段,我们可以推导出最优状态值函数 v(s)* 和最优动作值函数 q∗ (**s, a) 的贝尔曼最优方程:

qs,a=ERt+1+maxaʹq(St+1,aʹ)|St=s,At=a=∑s′,rp(s′,r|s,a)r+γmaxa′q*(s′,aʹ)

对于有限马尔可夫决策过程(MDP),贝尔曼最优性方程只有一个解,如果我们知道系统的动态特性,那么它们是可以被解决的。一旦我们得到 v,就很容易识别出最优策略 q;拥有最优的 q,我们就可以识别出最优动作。v 的美妙之处在于它允许我们在考虑长期目标的同时选择最佳动作。为一个问题求解这些方程就是通过强化学习(RL)来解决问题。另一方面,对于许多问题,解决它们意味着计算所有可能性,因此计算成本过高。在其他情况下,我们可能无法确定环境的动态特性,或者状态可能不具有马尔可夫性质。然而,这些方程是强化学习的基础,许多方法都是这些方程的近似,通常使用先前状态的经验。因此,这些算法并不识别最佳策略,而是识别一个近似。例如,许多算法学习最频繁状态的最优动作,但可能对不常见或罕见的状态选择次优动作。技巧是这些选择不应影响未来的奖励量。例如,即使代理在罕见情况下没有做出最佳动作,它仍然可能赢得游戏。

DP 指的是一组算法,这些算法用于在给定环境的完美模型作为马尔可夫决策过程(MDP)的情况下计算最佳策略。现在,这些算法需要大量的计算,并且完美模型的假设并不总是成立。因此,这些算法不再实际使用;同时,今天可以将算法定义为受 DP 算法启发,目的是减少计算量,即使在环境完美模型的假设不成立的情况下也能工作。简而言之,DP 算法是通过将贝尔曼方程转换为更新规则来改进所需价值函数的近似而获得的。这允许使用价值函数来组织对良好策略的搜索。为了评估策略,我们可以使用状态价值函数,并评估遵循策略 π 从每个状态预期的回报:

vπs=ERt+1+γvπ(St+1)|St=s,At=a=∑aπ(a|s)∑s′,rp(s′,r|s,a)[r+γvπ(s′)]

计算策略的价值函数旨在识别更好的策略。对于一个状态 s,我们想知道是否应该保持该策略,改进它,或者选择另一个策略。记住,策略的选择决定了智能体将采取哪些行动。为了回答“改变策略是否更好?”这个问题,我们可以考虑在状态 s 下遵循策略 π 选择一个动作会发生什么:

qπs,a=ERt+1+γvπ(St+1)|St=s,At=a=∑s′,rp(s′,r|s,a)[r+γvπ(s′)]

一个更好的策略 π’ 应该为我们提供更好的 vπ(s) 值。如果 π’ 小于或等于 vπ(s),我们可以继续相同的策略。换句话说,根据具有更好 vπ(s) 的策略 π’ 来选择动作比另一个策略 π 更有益。

在本节中,我们看到了经典的强化学习算法,但它们都没有使用神经网络或其他机器学习模型。这些算法在简单情况下表现良好,而对于更复杂的情况,我们希望有一个更复杂和适应性强的系统。在下一节中,我们将看到如何将神经网络集成到强化学习算法中。

深度强化学习

深度强化学习(深度强化学习)是强化学习的一个子领域,它将强化学习与深度学习相结合。换句话说,其背后的思想是利用神经网络的学习能力来解决强化学习问题。在传统的强化学习中,策略和价值函数由简单的函数表示。这些方法在低维状态和动作空间中表现良好(即当环境和代理可以轻松建模时)。当环境变得更加复杂或更大时,传统方法无法泛化。在深度强化学习中,策略和价值函数由神经网络表示。理论上,神经网络可以表示任何复杂的函数(通用逼近定理),这使得深度强化学习方法能够解决具有高维状态空间的问题(如呈现图像、视频或连续任务)。通过建模复杂函数,这使得代理能够学习到更通用和灵活的策略,这在复杂情况下是必要的,在这些情况下,使用传统方法定义函数是不可能的。这种学习能力使得深度强化学习方法能够解决视频游戏、移动机器人等问题。

图 8.13 – 深度强化学习概述(img/B21257_08_13.jpg)

图 8.13 – 深度强化学习概述 (arxiv.org/abs/1708.05866)

在接下来的小节中,我们将讨论如何对这些算法进行分类以及它们之间的区别。

无模型与基于模型的比较方法

目前深度强化学习的方法如此之多,以至于很难对这些模型进行分类。尽管如此,深度强化学习方法可以大致分为两大类:无模型和基于模型。这种划分可以通过回答以下问题来表示:智能体是否有权访问(或学习)环境的模型?

  • 无模型方法:这些方法在不需要构建环境模型的情况下确定最优策略或价值函数。这些模型直接从观察到的状态、动作和奖励中学习。智能体直接从试错中学习,从环境中获得反馈,并使用这些反馈来改进其策略或价值估计。这些方法通常更容易实现和进行参数调整(它们只需要观察状态-动作-奖励序列或转换)。它们也更容易扩展,计算复杂度更低。

  • 基于模型的方法:这些方法依赖于环境内部模型来预测给定任何状态-动作对的未来状态和奖励。这个模型可以在训练前学习或预先定义。拥有模型允许智能体在类似情况下进行规划和为未来场景(例如,游戏中对手的未来动作以及预测它们)制定计划。基于模型的方法的优势在于它们可以减少与真实环境的交互,并且在规划复杂任务方面表现更好。潜在的改进性能是以增加复杂性(构建准确的环境模型可能具有挑战性,尤其是在高维环境中)和增加计算成本为代价的。

图 8.14 – 无模型与基于模型的比较方法

图 8.14 – 无模型与基于模型的比较方法

基于模型强化学习方法的主要优势在于其规划和前瞻性思考的能力。通过利用模型(通常是一个神经网络)来模拟环境的动态,它可以预测未来场景,这在复杂环境或需要考虑长期结果的情况下特别有用。例如,当奖励稀疏或延迟——如在国际象棋中,只有赢得游戏才能获得奖励——模型可以模拟各种路径以优化智能体达到奖励的策略。

在动态环境中,规划也证明是有益的。模型可以快速更新其内部表示,使智能体能够调整其策略而无需从头开始重新学习。这最小化了大量重新训练的需求,如在自动驾驶等应用中,智能体可以调整其策略而无需大量新的数据集。从这种规划中获得的认识可以随后被提炼成学习策略,随着时间的推移提高智能体的性能。

此外,模拟与环境交互减少了大量现实世界探索的需求,这在交互成本高、危险或耗时的情况下至关重要,例如在机器人或自动驾驶汽车中。通过利用其内部模型,智能体可以优先考虑行动并优化其探索过程,以更有效地更新或改进其对环境的理解。

这有助于智能体优化长期目标,因为它可以模拟其行动的长期后果,监控其向更远目标的进展,并使其行动与遥远的目标保持一致。

模型构建可能是一项复杂的任务。然而,环境的确切模型并不总是对智能体可用。在这种情况下,智能体被迫仅从经验中学习以创建自己的模型。这可能导致智能体模型中的偏差。因此,智能体可能在学习的模型上表现最优,但在真实环境中表现极差(或次优)。

在策略方法和离策略方法之间

在强化学习(RL)中,另一个重要的分类是模型如何从经验中学习,以及它们是否从当前策略或不同策略中学习(它们根据策略与策略更新的关系进行分类):

  • 策略学习方法:这些方法从代理当前策略中学习到的动作中进行学习(因此代理既收集数据又从同一策略中学习)。策略学习方法评估和改进用于决策的策略;这是基于遵循当前策略时采取的动作和收到的奖励(代理通过直接评估和改进策略来执行策略更新)。因此,代理不使用来自其他策略的数据。其优点是代理往往更稳定,且不太容易受到变化的影响(优化的策略实际上是用来与环境交互的策略)。策略学习方法效率不高,因为它们丢弃了从先前策略中获得的数据(样本效率低下),这限制了它们在复杂环境中的应用,因为它们需要大量的数据。此外,这些方法不太具有探索性,因此在需要更多探索的地方不太有益(它们更适用于稳定的环境)。一个例子是聊天机器人,它学习给出更好的答案来回答用户的问题:聊天机器人使用特定的策略来给出答案,并通过利用从用户那里收到的反馈来优化这个策略。策略学习方法确保学习到的策略与聊天机器人采取的动作以及与用户的真实互动相关联(这确保了稳定性)。

  • 离策略方法:离策略方法独立于智能体的动作学习最优策略的价值(智能体从由不同策略生成并由学习策略使用的经验中学习)。因此,这些方法可以从过去的数据或由其他策略生成的数据中学习。离策略方法将行为策略(用于收集数据)与目标策略(正在学习策略)分开。换句话说,行为策略用于探索环境,而目标策略用于提高智能体的性能(在学习最优目标策略的同时确保更多的探索行为)。离策略方法具有更高的样本效率,因为它们可以重用数据并允许更好的探索,这可以导致更快地收敛到最优策略。另一方面,它们不太稳定(因为它们不学习当前策略已经采取的动作,行为策略和目标策略之间的差异可能导致更新中的更高方差)并且可能更加复杂。一个例子是音乐推荐系统,它向用户推荐新的标题,并必须探索不同的流派和新发行的音乐。行为策略鼓励探索,因此生成关于用户偏好的数据,而目标策略寻求优化用户的推荐性能。将这两种策略分开可以尝试不同的推荐策略,而不会影响最终推荐的品质。这些方法的优势在于它们允许广泛的探索,这对于复杂和动态环境非常有用。

图 8.15 – 在策略和离策略方法

图 8.15 – 在策略和离策略方法

在下一个子节中,我们将开始详细讲解深度强化学习是如何工作的。

详细探索深度强化学习

我们将从定义开始,以便更好地理解深度强化学习。在一个系统中的状态 s 通常是一个向量、矩阵或其他张量。在每个时间步 t,我们可以将环境描述为张量的形式(例如,棋盘上棋子的位置可以用矩阵表示)。同样,智能体可以选择的动作 a 也可以用张量表示(例如,每个动作可以关联到一个独热向量、一个矩阵等)。所有这些都是机器学习中已经常见的结构,我们可以将它们作为深度学习模型的输入。

到目前为止,我们泛泛地讨论了策略,但我们使用什么函数来建模它们?通常,我们使用神经网络。因此,在本节中,我们将积极探讨神经网络如何在强化学习算法中使用。我们现在看到的是基于本章的内容,但我们将使用神经网络来决定采取什么行动(而不仅仅是函数)。正如我们在第一章中看到的,神经网络由一系列按层次组织在一起的神经元组成。神经网络以张量作为输入并产生张量作为输出。在这种情况下,神经网络的输出是选择一个动作。在这种情况下,优化策略意味着优化神经网络的参数。基于经验的强化学习算法可以改变策略函数的参数,使其产生更好的结果。

图 8.16 – 作为强化学习策略的神经网络

图 8.16 – 作为强化学习策略的神经网络

神经网络是众所周知的深度学习模型,我们了解如何优化它们。使用基于梯度的方法使我们能够理解参数变化如何影响函数的输出。在这种情况下,我们想知道我们应该如何更新我们的策略 P(神经网络模型)的参数,以便在将来收集更多的奖励。因此,有一个函数告诉我们策略的预期奖励,我们可以使用梯度来改变策略的参数,从而最大化回报。

在强化学习中使用神经网络作为策略有几个优点:

  • 神经网络是高度表达的功能逼近器,因此它们可以映射输入(状态)和输出(动作)之间的复杂非线性关系。这对于复杂环境非常有用,例如玩电子游戏或控制 3D 环境中的机器人。此外,神经网络对于具有大而复杂的状态和动作空间的环境具有良好的扩展性。

  • 神经网络具有将情况推广到他们之前未遇到的情况的能力。这种能力使它们在处理意外状态变化时特别有用,从而促进了智能体的适应性。所有这些都使神经网络能够灵活适应不同范围的任务和环境。

  • 神经网络可以处理连续的动作而不是离散的动作,从而使其能够在现实世界问题中使用(在现实世界中,动作通常不受离散集合的限制)。

  • 神经网络是通用的。它们可以与不同类型的数据一起使用,并且不需要特征工程。当特征可能很复杂或状态表示很复杂(传感器、图像、视频等)时,这一点很重要。

  • 它们可以产生概率分布,因此可以与随机策略一起使用。当我们想要添加随机性和鼓励探索时,这一点很重要。

图 8.17 – 使用神经网络学习如何玩 Atari 游戏的截图示例

图 8.17 – 使用神经网络学习如何玩 Atari 游戏的截图示例 (arxiv.org/abs/1312.5602)

我们现在将介绍五种不同的算法,以便了解不同类型方法之间的差异(离政策和在线策略、无模型和基于模型的方法)。

图 8.18 – 强化学习方法的总结表

图 8.18 – 强化学习方法的总结表

Q 学习与深度 Q 网络(DQN)

Q 学习是深度 Q 网络(DQN)的基础,这是一种由 DeepMind 使用的算法,用于训练一个能够解决视频游戏的智能体。在 Q 学习算法中,我们有一个状态-动作值 Q 表,其中每一行代表一个状态,每一列代表一个动作,每个单元格包含对应状态-动作对的估计 Q 值。Q 值最初被设置为 0。当智能体从与环境交互中接收反馈时,我们迭代地更新这些值(直到它们收敛到最优值)。请注意,此更新使用贝尔曼方程进行(表中的 Q 值代表智能体从该状态采取该动作并随后遵循最佳策略时的预期未来奖励)。

Q 学习通过学习每个状态-动作对的优化 Q 值来找到最优策略。最初,智能体随机选择动作,但通过与环境的交互和接收反馈(奖励),它学会了哪些动作是最好的。在每次迭代中,它使用贝尔曼方程进行表格更新。智能体通常选择具有最高 Q 值的动作(贪婪策略),但我们可以通过控制探索程度(ε-贪婪策略)来控制。随着时间的推移,这些估计变得越来越准确,模型收敛到最优 Q 值。

图 8.19 – Q 学习示例

图 8.19 – Q 学习示例

在复杂环境中,由于可能的大规模和计算不可行性,使用表格存储值变得不切实际。相反,我们可以使用 Q 函数,它将状态-动作对映射到 Q 值。鉴于神经网络可以有效地模拟复杂函数,它们可以用来有效地近似 Q 函数。通过提供状态S作为输入,神经网络提供状态-动作对的 Q 值作为输出(换句话说,从该状态可以采取的所有动作的 Q 值)。原理与 Q 学习算法非常相似。我们开始时对 Q 值进行随机估计,使用ε-贪婪策略探索环境,并更新估计。

DQN 架构由三个主要组件组成:两个神经网络(Q 网络和目标网络)以及一个经验回放组件。Q 网络(一个经典的神经网络)是训练用来产生最优状态-动作值的代理。另一方面,经验回放用于生成训练神经网络所需的数据。

Q 网络在多个时间步和多个回合上进行训练,目的是最小化预测 Q 值和目标 Q 值之间的差异。在代理与环境交互的过程中,每个经验(状态、动作、奖励和下一个状态的元组)都存储在这个经验回放缓冲区中。在训练过程中,从缓冲区中随机选择经验批次(新旧经验的混合)来更新 Q 网络。这有助于打破连续经验之间的相关性(有助于稳定训练)并多次重用过去经验(提高数据效率)。目标网络是用于生成训练目标 Q 值的 Q 网络的副本。定期(例如每几千步)通过复制 Q 网络权重来更新目标网络权重;这稳定了训练。在训练过程中,Q 网络预测给定状态的行动 Q 值(预测 Q 值),目标网络预测给定状态的行动目标 Q 值。预测 Q 值、目标 Q 值和观察到的奖励用于计算损失并更新 Q 网络的权重。

图 8.20 – DQN 训练算法

图 8.20 – DQN 训练算法

DQN 有许多创新和优势:

  • 经验回放使训练更加稳定和高效。神经网络通常以一批数据作为输入,而不是单个状态,因此在训练过程中,梯度将具有更小的方差,权重收敛更快。经验回放还可以在训练过程中减少噪声,因为我们可以对经验进行一种“洗牌”,从而更好地实现泛化。

  • 目标网络的概念引入减轻了非平稳目标的问题,这可能导致训练不稳定。目标网络未经训练,因此目标 Q 值稳定且波动很小。

  • DQN 在处理高维空间如图像时非常有效,能够自行提取特征并学习有效的策略。这些能力使得 DQN 能够通过输入原始像素来掌握 Atari 游戏。

当然,也存在一些缺点:

  • 虽然它比 Q 学习更高效,但 DQN 仍然需要大量的样本来有效地学习;这限制了它在数据很少的任务中的应用(样本效率低)

  • 当动作空间是连续的时,它不稳定,而对于离散动作空间则表现良好

  • 它对超参数的选择(如学习率、重放缓冲区大小和目标网络更新频率)敏感

REINFORCE 算法

DQN 专注于在不同状态下学习动作的价值。REINFORCE则是一种基于策略的方法。这些方法直接学习策略,将状态映射到动作而不学习价值函数。核心思想是通过最大化代理在一段时间内收到的期望累积奖励来优化策略。REINFORCE 是学习如何训练代理处理复杂、连续动作空间的基础算法。

策略由一个神经网络表示,它以当前状态作为输入并产生一个关于所有可能动作的概率分布(代理执行特定动作的概率)。这被称为随机策略,因为我们没有直接输出动作,而是输出概率。策略梯度方法试图直接改进策略(通过在训练期间改变参数),以便策略产生更好的结果。因此,我们再次从一个随机策略(神经网络权重随机初始化)开始,让代理根据其策略在环境中行动,这会导致产生一个轨迹(一系列状态和动作)。如果这个轨迹收集到高奖励,我们将更新权重,使得这个轨迹在未来更有可能被产生。相反,如果代理表现不佳,权重的更新将指导使该轨迹不太可能发生。

图 8.21 – 轨迹示例

图 8.21 – 轨迹示例

因此,这个过程的第一步是初始化一个神经网络(策略P)及其参数θ。由于这些权重最初是随机的,以状态作为输入的策略将导致随机动作。然后我们生成一个轨迹τ,让代理与环境交互。从状态s0 开始,我们让代理根据策略P和参数θ进行移动。在实践中,状态S被作为输入给神经网络,并生成一个动作分布。我们从这个分布中采样一个动作a0。这个过程会尽可能重复(例如,直到游戏结束),状态和动作的集合就是我们的轨迹。

图 8.22 – 从神经网络获取分布

图 8.22 – 从神经网络获取分布

在轨迹过程中,我们收集奖励(称为奖励到去或也称为回报 Gt)。回报是从时间步 t 到剧集结束所收到的总累积奖励,通过一个因子 γ 进行折现。折现因子决定了未来奖励相对于即时奖励的重要性。在这种情况下,我们有一个函数,它为我们提供给定策略的预期回报,我们希望最大化它。因此,我们计算梯度,并通过梯度上升修改我们神经网络的参数。

REINFORCE 算法在概念上简单且易于实现,适用于连续动作空间(因为它直接学习策略),并支持端到端学习(算法直接从原始数据中学习)。然而,这个算法的一些挑战包括策略更新的高方差(它依赖于完整剧集的返回,更新可能嘈杂且不稳定),需要大量数据(因为它在每次更新后丢弃数据且不重复使用经验,所以需要大量的剧集),它不适用于数据昂贵的环境,并且在存在延迟奖励的情况下表现不佳。

注意,REINFORCE 算法是一个基于策略的算法,因为策略只根据使用相同策略收集的经验进行更新。在每次迭代中,智能体使用更新的策略并使用它来收集经验以进行更新。在离策略方法的情况下,也会使用使用其他策略收集的经验。例如,这就是我们在 DQN 中看到的情况,我们使用的是使用不同策略收集的批次经验。

近端策略优化(PPO)

近端策略优化(PPO)是强化学习中最广泛引用和使用的算法之一。由 OpenAI 于 2017 年引入,PPO 旨在平衡策略梯度方法(如 REINFORCE)的简单性与更复杂算法(如信任域策略优化(TRPO))的稳定性。本质上,PPO 是一个实用且高效的算法,在基准测试中表现良好,同时相对容易实现和调整。

PPO 与 REINFORCE 相似,但包括重要的改进,使训练更加稳定。基于策略的方法中的一个挑战是超参数的选择(尤其是学习率)以及不稳定权重更新的风险。PPO 的关键创新在于确保策略更新不要太大,因为这可能会破坏训练的稳定性。PPO 通过使用一个限制目标函数的约束来实现这一点,该约束限制了策略在单个更新中可以改变的程度,从而避免了网络权重的剧烈变化。

传统策略梯度方法的一个重大问题是它们无法从较差的更新中恢复。如果一个策略表现不佳,智能体可能在下一次迭代中生成稀疏或低质量的训练数据,从而形成一个难以摆脱的自我强化循环。PPO 通过稳定策略更新来解决这一问题。

在 PPO 中,策略由一个神经网络表示,πθ(a|s),其中θ代表网络的权重。网络将当前状态s作为输入,并输出一个关于可能动作a的概率分布。最初,权重是随机初始化的。随着智能体与环境交互,它根据当前策略生成经验批次(状态、动作、奖励)。智能体还计算优势估计,这衡量所选动作相对于状态期望值的优劣。

与简单的策略梯度方法的主要区别在于 PPO 使用剪辑目标函数。这个函数确保策略更新是稳定的,并防止出现大的、破坏性的变化。如果新旧策略之间的概率比rt(θ)超出范围[1−ϵ,1+ϵ],其中ϵ是一个小的超参数(例如,0.2),则更新将被剪辑。这种剪辑机制确保策略更新保持在安全范围内,防止策略在单次更新中偏离太多。

PPO 的一种常见变体使用actor-critic 架构,其中 actor 学习策略,而 critic 学习价值函数。critic 提供关于动作质量的反馈,有助于减少更新方差并提高学习效率(我们稍后会更详细地讨论这一点)。

总体而言,PPO 是一个既稳定又鲁棒的算法,比简单的策略梯度方法更不容易不稳定,比 TRPO 等更复杂的算法更容易使用。它不需要解决复杂的优化问题或计算二阶梯度,使其成为许多应用的实用选择。然而,PPO 仍然需要仔细调整超参数,例如剪辑参数ϵ、学习率和批量大小。此外,它可能在具有长周期或延迟奖励的环境中出现高方差。

Actor-critic 算法

Actor-critic 算法是 RL 中另一种流行的方法,它结合了两种不同方法的优势:基于价值的方法(如 Q-learning)和基于策略的方法。actor-critic 模型由两个组件组成:

  • Actor:actor 负责决定在环境当前状态下应该采取什么动作。策略通常是一个产生动作概率分布的神经网络。actor 通过优化策略来最大化期望回报。

  • 评价者:评价者通过估计价值函数来评估动作评价者采取的动作。这个函数表示一个动作在预期未来奖励方面的好坏。价值函数可以是状态价值函数 V(s) 或动作价值函数 Q(s,a)。

这种方法背后的洞察是,动作评价者是决策者,他学习如何随着时间的推移改进决策。另一方面,评价者是一种顾问,他评估动作的好坏,并对策略提供反馈。

图 8.23 – 动作-评价者方法

图 8.23 – 动作-评价者方法

该过程可以定义为四个步骤:

  1. 代理与环境交互,并根据其策略,基于当前状态选择一个动作。然后它从环境中以奖励和新的状态的形式接收反馈。

  2. 在第二步中,评价者使用奖励和新的状态来计算一个时间差分(TD)误差。TD 误差衡量评价者当前对价值函数的估计与观察结果之间的差距。TD 误差然后是时间步长 t 的奖励(加上评价者对下一个状态价值 V(st+1) 的估计的折扣因子 γ,以平衡即时和未来奖励的影响)与评价者对当前状态价值 V(st) 的估计之间的差异。

  3. 评价者通过梯度下降更新其价值函数参数以最小化 TD 误差。

  4. 动作评价者也会更新。动作评价者使用 TD 误差作为反馈信号。如果误差为正,这意味着动作比预期的好,动作评价者应该更频繁地采取这个动作(增加未来采取这个动作的概率)。如果误差为负,动作评价者应该减少概率。动作评价者使用梯度上升来最大化策略;我们希望最大化期望回报。

动作-评价者方法在连续动作空间中表现良好,而基于价值的方法存在问题。它是一个稳定且高效的方法,并减少了策略梯度更新的方差。另一方面,它对超参数敏感,你必须训练两个网络,并且它比 Q 学习或 REINFORCE 更复杂。

优势动作-评价者(A2C)是一个流行的变体,其中多个代理并行地与环境的多个实例交互。这允许更快地训练。

AlphaZero

AlphaZero 是 DeepMind 在 2017 年开发的一个开创性的基于模型的强化学习算法,能够掌握国际象棋、将棋(日本象棋)和围棋。它已经达到了超人类的表现,在这些游戏中击败了人类冠军。AlphaZero 的成功在于其创新性地结合了深度学习和蒙特卡洛树搜索(MCTS),这使得它能够在没有人类专业知识或手工制定的规则的情况下有效地学习和规划。

AlphaZero 完全通过自我对弈进行学习,除了游戏的基本规则外,没有任何先验知识。它与自己进行数百万次对弈,通过试错逐渐理解什么构成好或坏的走法。这种自我对弈的方法使得 AlphaZero 能够发现最优策略,通常甚至超过由专家人类玩家开发出的策略。此外,它还使模型能够生成大量的训练数据,远远超过仅通过分析人类游戏所能获得的数据。该算法使用深度神经网络来表示策略(采取哪些行动)和价值函数(从给定状态出发游戏的预期结果)。

传统的国际象棋引擎曾经依赖于游戏树搜索技术。在每一步,它们会构建一个表示从当前位置出发所有可能合法走法的游戏树,并执行到一定深度的深度优先搜索(DFS)。这种蛮力搜索检查了所有合法走法,根据由棋类社区制定的启发式评估为最终节点分配值。这些启发式,如国王安全、兵的结构和中心控制,模仿了人类棋手用来判断走法质量的因素。

在评估最终节点后,传统引擎会回溯并分析位置,剪枝较少有希望的分支以简化搜索。尽管有这些优化,这种方法仍然有限制,往往导致次优走法,并且计算成本高昂。这就是 MCTS(蒙特卡洛树搜索)的用武之地。

MCTS 是一种算法,用于在需要提前规划数步的环境中进行决策,特别是在具有大状态空间的游戏中,其中全面搜索是不可行的。MCTS 通过多次模拟游戏来构建搜索树,逐渐通过经验改进对最佳行动的理解。

MCTS 通过以下四个主要步骤操作,重复以细化搜索树:

  1. 选择:从根节点(当前状态)开始,算法使用一种平衡探索(尝试较少探索的走法)和利用(选择已显示出希望的走法)的策略选择子节点。这通常使用树的上界置信度(UCT)公式来完成,该公式考虑了每个节点的平均奖励和访问次数。

  2. 扩展:如果选定的节点不是终端状态(游戏的结束),算法会添加一个或多个子节点,代表从该状态出发的可能行动。这种扩展使得搜索能够覆盖新的潜在走法和结果。

  3. 模拟(滚动出):从新添加的节点开始,MCTS 通过使用简单或随机策略将游戏玩到终端状态来进行模拟,或称为“滚动出”。这个模拟的结果(赢、输或平局)提供了一个奖励,作为对采取的行动价值的估计。

  4. 反向传播:然后,将模拟的奖励反向传播到树中,更新从根节点到路径上每个节点的值。这包括更新每个节点的平均奖励和访问次数。随着时间的推移,这些更新帮助算法确定哪些移动最有希望。

图 8.24 – 蒙特卡洛树搜索 (https://en.wikipedia.org/wiki/Monte_Carlo_tree_search)

图 8.24 – 蒙特卡洛树搜索 (en.wikipedia.org/wiki/Monte_Carlo_tree_search)

AlphaZero 随后使用一个神经网络(一个以棋盘上棋子排列为输入的卷积神经网络)并产生两个输出:策略头(所有可能移动的概率分布,指导智能体考虑哪些移动)和价值头(从当前棋盘位置获胜的可能性,帮助智能体评估各种状态的力量)。AlphaZero 使用 MCTS 来模拟潜在的移动及其结果(智能体在游戏中计划数步)。通过 MCTS,模型探索看似最有希望的移动,并逐渐提高其对游戏的理解。树搜索使用神经网络的策略和价值输出来优先考虑探索树的哪些分支。AlphaZero 通过自我对弈(自我玩耍)来学习。在每一场比赛中,智能体使用 MCTS 来决定移动并保存状态(棋盘上的位置)、选择的移动和结果。这些数据用于改进策略和价值估计(神经网络权重更新)。

图 8.25 – AlphaZero 流程 (https://www.mdpi.com/2079-9292/10/13/1533)

图 8.25 – AlphaZero 流程 (www.mdpi.com/2079-9292/10/13/1533)

因此,AlphaZero 提出了三个主要创新:

  • 跨游戏泛化:相同的算法用于三种不同的游戏(国际象棋、将棋和围棋),无需针对特定游戏进行调整。

  • 无需人类知识:与使用大量人类游戏和策略数据库的传统棋类引擎不同,AlphaZero 自行学习游戏。该模型优先考虑在游戏中提供长期奖励的策略,而不是仅仅关注单个移动的即时收益。这种方法使模型能够发现人类或传统棋类引擎未曾探索的创新策略。

  • 高效的搜索和学习:使用 MCTS 和深度学习允许更有效地使用计算资源。AlphaZero 不是对所有可能的移动进行广泛的搜索,而是仅关注最有希望的移动。

当然,AlphaZero 也不是没有缺陷。该算法的计算成本巨大,因为它必须与自己玩数百万场比赛。此外,该算法在游戏(或信息完全的环境)中表现良好,但将其适应到信息不完整的环境则更困难。最后,关于实际上理解游戏或学习抽象概念存在讨论,因为模型在某些对人类来说很容易的棋类谜题上失败了。

在下一个子节中,我们将讨论强化学习(RL)的挑战以及新的、令人兴奋的研究方向。

深度 RL 的挑战和未来方向

尽管 RL 取得了重大进展,但仍然存在一些挑战和活跃的研究方向:

  • 在未见过的环境中的泛化:在智能体未见过的环境中的泛化仍然是一个复杂任务。智能体通常在模拟环境中或特定设置中进行训练,在训练后能够表现出色。然而,将学习到的技能转移到新环境、动态环境或变化条件下是困难的。这限制了深度 RL 算法在现实世界中的应用,因为现实环境很少是静态或完全可预测的。真正的泛化要求模型不仅学习特定任务的解决方案,而且能够适应各种情况(即使这些情况在训练期间没有发生)。

  • 奖励函数设计:奖励函数控制智能体的行为、学习和表现。设计奖励函数很困难,尤其是在复杂、分散的环境中。在稀疏奖励设置中,由于反馈有限且通常延迟,定义奖励和函数是复杂但至关重要的。即便如此,仍然存在创建偏差的风险,导致策略过度拟合或出现意外行为,或者使其次优。

  • 基于模型的规划中的复合误差:基于模型的 RL 存在复合误差的风险。预测的视野越长,模型预测中的错误积累越多,导致与最优轨迹的显著偏差。这在复杂或高维空间环境中尤其如此,因此限制了它们在现实环境中的应用。

  • 多任务学习:创建一个可用于多个任务的智能体仍然很困难,存在风险是智能体只学会了较容易的任务而忽略了更复杂(或表现非常差的)任务。此外,多任务模型通常的表现远低于针对单个任务优化的智能体。因此,设计可用于多任务 RL 的智能体是困难的,并且仍然是一个活跃的研究领域。

  • 多模态强化学习:随着计算机视觉和自然语言处理技术的进步,现在有一些深度学习模型可以单独处理一种模式,或者同时处理多种模式。这就是为什么越来越多的讨论使用多模态强化学习,其中智能体可以在多模态环境中移动,并整合来自各种模态的信息。例如,机器人可以从图像中获取环境信息,并以自然语言接收命令或指令。在视频游戏中,智能体接收视觉信息,但也会从与角色的对话或其他玩家那里获取信息。多模态学习仍然很复杂,因为智能体必须同时学习如何处理多模态信息并优化策略以在复杂环境中交互。同样,为这些情况设计奖励函数仍然很困难。

在下一节中,我们将看到如何使用神经网络来学习如何玩视频游戏。

使用强化学习学习如何玩视频游戏

在本小节中,我们将讨论如何训练智能体来玩视频游戏。在这种情况下,智能体将由神经网络参数化。遵循此策略,它将在视频游戏允许的动作中进行选择,从环境中获得反馈,并使用这些反馈进行参数更新。一般来说,视频游戏提供复杂和动态的环境,模拟现实世界场景,因此它们是强化学习算法的优秀测试平台。视频游戏提供高维状态空间(基于像素的状态,详细的世界)和丰富的动作空间(离散或连续),灵感来源于现实世界,可以提供即时和延迟的奖励(例如,某些动作可能导致主角直接死亡,而解决谜题或赢得游戏则需要长期策略)。此外,许多游戏要求用户在掌握环境之前先探索环境。敌人通常是动态的,模型必须学习如何击败对手或理解复杂行为以克服它们。游戏还提供清晰的奖励(通常是频繁的或可以加速的),这使得奖励函数可以轻松定义,从而成为一个安全的游乐场(例如,用于机器人算法)。此外,还有明确的基准,可以快速比较新算法的质量。

我们选择 actor-critic 方法进行此训练,因为它具有以下特点:

  • Actor-critic 可以处理复杂和连续的动作空间(例如控制 3D 环境中的角色),因此可以用于各种游戏。

  • 系统中的 actor 直接学习策略,这使得在找到策略至关重要的场景中效率更高。这在需要快速决策和战略规划的视频游戏中是必要的。

  • 与纯粹基于策略的方法相比,评论家提供了反馈并加快了学习速度。使用价值函数(评论家)来评估动作减少了策略更新的方差,因此在奖励分散的环境中更加稳定和高效。

  • 行为者-评论家允许高效地管理探索和利用之间的平衡,其中行为者通过探索环境,而评论家通过提供反馈来引导它。对于更复杂的环境,行为者-评论家可能不足以满足需求,尽管它是一个良好的初始选择,并且通常足够用。

  • 行为者-评论家(Actor-critic)也可以处理长期规划。在视频游戏中,往往存在长期奖励;评论家的价值函数帮助代理理解其行动的长期影响。

  • 一些变体在并行化和使用数据方面效率很高。A2C 是并行化环境和收集更多数据的良好选择,从而加快训练和收敛速度。

我们选择超级马里奥作为我们的游戏,因为它提供了一个丰富且复杂的环境。这个环境类似于现实世界,像素观察作为输入的表示与真实世界计算机视觉任务相似,这使得超级马里奥成为需要从视觉数据中提取有意义特征的强化学习代理的良好测试平台。这个环境也是部分可观察的,因此需要代理去探索和学习环境。不同的关卡可能需要不同的策略,因此模型必须能够平衡探索和利用。

在游戏中,存在不同种类的挑战,例如导航障碍、面对不同种类的敌人,以及学习最优和动态地跳跃。这些不同的挑战代表了代理应该发展的不同技能:测试代理做出精确和及时行动的能力(跳过障碍或缺口),评估威胁并决定何时避免或参与(避免或参与敌人),以及空间意识和战略规划(导航复杂关卡)。关卡是逐步增加的,因此难度随着代理的学习而增加。此外,既有即时奖励(收集金币),也有延迟奖励(例如,完成关卡),从而允许评估长期策略。

最后,超级马里奥在强化学习研究社区中被广泛采用作为基准。主要的库都支持它,或者它被直接集成,从而允许快速测试算法或进行比较。同时,也有已经深入研究过的策略;游戏文档详尽,是强化学习初学者和专家的良好示例。此外,还有一些可并行化的实现,从而允许有效且快速的训练。

图 8.26 – 超级马里奥训练截图

图 8.26 – 超级马里奥训练截图

所有代码都可以在以下链接的仓库中找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr8/RL_SuperMario

图 8.27 – 仓库截图

图 8.27 – 仓库截图

脚本描述

为了执行训练,我们将使用一些流行的强化学习库(OpenAI 的 Gym 和 PyTorch)。在仓库中,有一些用于训练智能体的不同脚本:

  • env:此脚本定义了我们的智能体行动的环境(超级马里奥),并允许我们记录智能体玩游戏的视频,预处理模型图像,定义奖励函数,设置世界,设置虚拟摇杆等。

  • model:此脚本定义了一个用于演员-评论家架构的 PyTorch 神经网络模型。该模型旨在处理类似图像的输入,提取特征,然后使用这些特征输出动作概率(演员)和状态价值估计(评论家)。

  • optimizer:此代码定义了一个名为 GlobalAdam 的自定义优化器类,它扩展了 PyTorch 内置的 Adam 优化器的功能。

  • train:此脚本使用异步优势演员-评论家(A3C)方法设置和运行一个分布式强化学习系统,以训练一个能够玩超级马里奥兄弟的智能体。

  • test:模型测试在单独的脚本中。此脚本允许您加载训练好的模型来玩游戏,同时渲染游戏过程。

  • process:此脚本作为连接件,将所有前面的组件集成到一个统一的强化学习系统中,用于训练和测试玩超级马里奥兄弟的智能体。

图 8.28 – 脚本的全局视图

图 8.28 – 脚本的全局视图

设置环境

env 脚本允许我们设置环境,特别是对于深度 Q 学习或演员-评论家等强化学习算法。在脚本中,我们导入所需的库,之后有一些用于创建世界和定义智能体如何与之交互的函数:

  • Monitor:Monitor 类允许用户保存智能体游戏过程的视觉记录,这对于调试、分析智能体性能和分享结果非常有用。此函数允许我们使用 .ffmpeg 保存游戏视频。

  • process_frame:process_frame 函数用于预处理游戏帧,使其更适合训练强化学习智能体。此函数检查帧是否为正确格式,将其转换为灰度并减小尺寸,然后进行归一化(简化输入)。这允许智能体专注于视觉信息的重要细节。

  • CustomReward:这是对奖励的修改,以鼓励有用的行为,跟踪当前分数,添加奖励,检查代理是否完成关卡,如果没有完成则对其进行惩罚。这样,它试图通过惩罚失败来激励完成关卡并取得进步。

  • CustomSkipFrame:这个功能通过允许跳过帧来加速训练,从而减少计算量(更少的环境更新)。

  • create_train_env:这个函数设置了一个完全定制和优化的超级马里奥环境,使其准备好用高效的预处理、奖励塑造和帧跳过训练 RL 代理。

定义模型

在model脚本中,我们定义了算法的架构。ActorCritic类控制着架构,作为一个神经网络,它基于 PyTorch(实际上,我们使用nn.Module,这是 PyTorch 中的一个经典神经网络)。该类有两个组件代表Actor(负责选择动作)和Critic,它提供反馈。你可以看到我们有一个共享的特征提取器:

self.conv1 = nn.Conv2d(num_inputs, 32, 3, stride=2, padding=1)
self.conv2 = nn.Conv2d(32, 32, 3, stride=2, padding=1)
self.conv3 = nn.Conv2d(32, 32, 3, stride=2, padding=1)
self.conv4 = nn.Conv2d(32, 32, 3, stride=2, padding=1)
self.lstm = nn.LSTMCell(32 * 6 * 6, 512)

这里,我们有一个卷积网络来从游戏中提取空间特征;然后这个输出被重塑成一个 2D 张量,传递给 LSTM。LSTM 更新隐藏状态hx和细胞状态cx(我们在第一章中详细描述了 LSTM),从而管理游戏记忆。

之后,我们初始化这两个组件:

self.critic_linear = nn.Linear(512, 1)
self.actor_linear = nn.Linear(512, num_actions)

使用单个特征提取器允许我们节省计算资源。两个组件产生两个不同的输出:actor_linear为 actor 生成输出,它是一个大小为num_actions的向量。这代表了采取每个动作的概率。critic_linear组件为 critic 生成输出,它是一个单一的标量值。这个值代表了当前状态的估计值(从这个状态期望的回报)。这种分离确保了两个层有各自的目标和不同的学习信号。

接下来,我们将定义不同的损失函数,以便允许不同的学习。正如我们所见,两个组件产生不同的输出:

def forward(self, x, hx, cx):
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        x = F.relu(self.conv3(x))
        x = F.relu(self.conv4(x))
        hx, cx = self.lstm(x.view(x.size(0), -1), (hx, cx))
        return self.actor_linear(hx), self.critic_linear(hx), hx, cx

由于我们希望我们的进程针对分布式学习进行优化,我们使用 Adam 的自定义版本。Adam 是一种经典的优化器,用于更新神经网络的参数。GlobalAdam 类是为分布式强化学习设计的,其中多个进程或智能体共享相同的优化器。关键思想是使优化器状态的一部分在进程间共享,允许智能体高效地协调对模型参数的更新。这特别适用于演员-评论家和特别是有多个智能体在相同环境中行动的变体。想法是我们异步玩几轮游戏,然后进行全局更新,减少计算。GlobalAdam 脚本简单地将 Adam 适配到强化学习问题,允许从不同进程中进行平均和学习:

import torch
class GlobalAdam(torch.optim.Adam):
    def __init__(self, params, lr):
        super(GlobalAdam, self).__init__(params, lr=lr)
        for group in self.param_groups:
            for p in group['params']:
                state = self.state[p]
                state['step'] = 0
                state['exp_avg'] = torch.zeros_like(p.data)
                state['exp_avg_sq'] = torch.zeros_like(p.data)
                state['exp_avg'].share_memory_()
                state['exp_avg_sq'].share_memory_()

训练模型

train 脚本允许我们使用不同的进程异步训练模型。脚本允许我们提供几个参数(默认参数已经输入)。例如,我们可以决定游戏的难度级别(--world 和 --stage),动作的类型(--action_type),优化器的学习率(--lr),针对算法和强化学习(RL)的特定超参数(--gamma,--tau,--beta),或者与进程及其并行化相关的参数(--num_processes,--num_local_steps 和 --num_global_steps)。

train 函数允许我们初始化训练环境,初始化策略,并使用 GPU。global_model.share_memory() 方法允许全局模型的参数对所有进程可访问,从而实现并行更新。您可以看到我们使用 GlobalAdam 来更新全局模型的参数。torch.multiprocessing 包装器(是对多进程模块的包装)允许我们创建多个异步操作的多进程。然后,此脚本定义了使用多个并行进程训练我们的模型。同时,脚本允许轻松配置和定制:

def train(opt):
    torch.manual_seed(123)
    if os.path.isdir(opt.log_path):
        shutil.rmtree(opt.log_path)
    os.makedirs(opt.log_path)
    if not os.path.isdir(opt.saved_path):
        os.makedirs(opt.saved_path)
    mp = _mp.get_context("spawn")
    env, num_states, num_actions = create_train_env(opt.world, opt.stage, opt.action_type)
    global_model = ActorCritic(num_states, num_actions)
    if opt.use_gpu:
        global_model.cuda()
    global_model.share_memory()
    if opt.load_from_previous_stage:
        if opt.stage == 1:
            previous_world = opt.world - 1
            previous_stage = 4
        else:
            previous_world = opt.world
            previous_stage = opt.stage - 1
        file_ = "{}/A3CSuperMarioBros{}_{}".format(opt.saved_path, previous_world, previous_stage)
        if os.path.isfile(file_):
            global_model.load_state_dict(torch.load(file_))
    optimizer = GlobalAdam(global_model.parameters(), lr=opt.lr)
    processes = []
    for index in range(opt.num_processes):
        if index == 0:
            process = mp.Process(target=local_train, args=(index, opt, global_model, optimizer, True))
        else:
            process = mp.Process(target=local_train, args=(index, opt, global_model, optimizer))
        process.start()
        processes.append(process)
    process = mp.Process(target=local_test, args=(opt.num_processes, opt, global_model))
    process.start()
    processes.append(process)
    for process in processes:
        process.join()

测试系统

test 脚本允许定制,例如决定一些参数,如游戏难度、动作等。一旦我们训练了我们的模型,我们就可以加载它,玩游戏,并注册正在玩游戏的智能体。然后,模型根据其策略进行游戏,在此脚本中没有进行优化,因此允许我们观察智能体的表现。

连接所有组件

process 脚本将我们迄今为止看到的所有脚本连接成一个系统。此脚本使用 env 模块中的 create_train_env 函数来设置超级马里奥兄弟游戏环境。这是我们代理与环境交互并学习的地方。脚本还初始化了 ActorCritic 模型(包括演员和评论家),并使用此模型做出决策和评估游戏状态。local_train 函数负责训练,需要 GlobalAdam 优化器。此脚本还用于评估训练模型性能,因此它使用了我们在测试脚本中定义的元素。因此,这个脚本是我们拥有一个完全功能性的强化学习系统的核心部分。它协调环境、模型和训练算法,使一切协同工作以训练一个能够玩超级马里奥兄弟的代理。

local_train 函数使代理能够在更新共享的全局模型的同时并行训练。此函数为可重复性设置了一个种子,因此我们可以重现结果。之后,我们初始化环境(create_train_env)和模型(ActorCritic);如果有 GPU,我们将模型移动到 GPU 并初始化 TensorBoard:

def local_train(index, opt, global_model, optimizer, save=False):
    torch.manual_seed(123 + index)
    if save:
        start_time = timeit.default_timer()
    writer = SummaryWriter(opt.log_path)
    env, num_states, num_actions = create_train_env(opt.world, opt.stage, opt.action_type)
    local_model = ActorCritic(num_states, num_actions)
    if opt.use_gpu:
        local_model.cuda()

在这个点上,我们开始训练循环,其中每个迭代代表一次游戏回合。局部参数与全局参数同步,在每个回合结束时,LSTM 的隐藏和细胞状态被重置:

local_model.train()
    state = torch.from_numpy(env.reset())
    if opt.use_gpu:
        state = state.cuda()
    done = True
    curr_step = 0
    curr_episode = 0
    while True:
        if save:
            if curr_episode % opt.save_interval == 0 and curr_episode > 0:
                torch.save(global_model.state_dict(),
                           "{}/a3c_super_mario_bros_{}_{}".format(opt.saved_path, opt.world, opt.stage))
            print("Process {}. Episode {}".format(index, curr_episode))
        curr_episode += 1
        local_model.load_state_dict(global_model.state_dict())
        if done:
            h_0 = torch.zeros((1, 512), dtype=torch.float)
            c_0 = torch.zeros((1, 512), dtype=torch.float)
        else:
            h_0 = h_0.detach()
            c_0 = c_0.detach()
        if opt.use_gpu:
            h_0 = h_0.cuda()
            c_0 = c_0.cuda()

在这个阶段,我们开始收集多个步骤(opt.num_local_steps)的经验。然后,对于某个状态,模型(局部模型)生成一组概率,并从这些概率中采样一个动作。选择了一个动作后,我们与环境交互,从而获得奖励和新的状态。对于这些步骤中的每一个,我们记录以下内容:是否结束了一个回合,动作的对数概率,价值估计,奖励和政策熵。如果回合结束,状态被重置,隐藏状态被断开以防止梯度反向传播:

for _ in range(opt.num_local_steps):
            curr_step += 1
            logits, value, h_0, c_0 = local_model(state, h_0, c_0)
            policy = F.softmax(logits, dim=1)
            log_policy = F.log_softmax(logits, dim=1)
            entropy = -(policy * log_policy).sum(1, keepdim=True)
            m = Categorical(policy)
            action = m.sample().item()
            state, reward, done, _ = env.step(action)
            state = torch.from_numpy(state)
            if opt.use_gpu:
                state = state.cuda()
            if curr_step > opt.num_global_steps:
                done = True
            if done:
                curr_step = 0
                state = torch.from_numpy(env.reset())
                if opt.use_gpu:
                    state = state.cuda()
            values.append(value)
            log_policies.append(log_policy[0, action])
            rewards.append(reward)
            entropies.append(entropy)
            if done:
                break
        R = torch.zeros((1, 1), dtype=torch.float)
        if opt.use_gpu:
            R = R.cuda()
        if not done:
            _, R, _, _ = local_model(state, h_0, c_0)

现在,是计算损失和进行反向传播的时候了。在这里,我们使用广义优势估计(GAE)来平衡偏差和方差,从而使训练更加高效。简单来说,优势函数 A(s,a) 衡量了一个动作 a 相对于给定状态 s 中平均动作的好坏。在下一个脚本中,GAE 用于计算推动演员策略更新的优势值。我们使用 GAE 在演员损失中更新策略,以最大化期望回报但保持方差低。换句话说,我们希望使训练更加稳定。通过添加 GAE,训练过程变得更加高效,并且对高方差回报的噪声或偏差价值估计的不准确性的敏感性降低:

        gae = torch.zeros((1, 1), dtype=torch.float)
        if opt.use_gpu:
            gae = gae.cuda()
        actor_loss = 0
        critic_loss = 0
        entropy_loss = 0
        next_value = R
        for value, log_policy, reward, entropy in list(zip(values, log_policies, rewards, entropies))[::-1]:
            gae = gae * opt.gamma * opt.tau
            gae = gae + reward + opt.gamma * next_value.detach() - value.detach()
            next_value = value
            actor_loss = actor_loss + log_policy * gae
            R = R * opt.gamma + reward
            critic_loss = critic_loss + (R - value) ** 2 / 2
            entropy_loss = entropy_loss + entropy
        total_loss = -actor_loss + critic_loss - opt.beta * entropy_loss
        writer.add_scalar("Train_{}/Loss".format(index), total_loss, curr_episode)
        optimizer.zero_grad()
        total_loss.backward()
        for local_param, global_param in zip(local_model.parameters(), global_model.parameters()):
            if global_param.grad is not None:
                break
            global_param._grad = local_param.grad
        optimizer.step()
        if curr_episode == int(opt.num_global_steps / opt.num_local_steps):
            print("Training process {} terminated".format(index))
            if save:
                end_time = timeit.default_timer()
                print('The code runs for %.2f s ' % (end_time - start_time))
            return

注意,我们有三个独立的损失。第一个是演员损失,它鼓励导致更高奖励的动作。评论员损失惩罚价值估计中的错误,熵损失通过惩罚过于自信的动作分布(在其他过于贪婪的惩罚策略中)来鼓励探索。一旦我们计算了总损失,我们就像任何神经网络一样执行反向传播。目前,我们已经完成了本地训练,因此我们使用本地模型的梯度来进行全局模型更新。每隔一定时间间隔,我们保存模型并将损失日志发送到 TensorBoard。当达到总的全局步数时,过程结束。

local_test 函数允许我们评估训练好的模型。它作为一个独立的过程运行,以测试代理使用学习到的策略的表现:

def local_test(index, opt, global_model):
    torch.manual_seed(123 + index)
    env, num_states, num_actions = create_train_env(opt.world, opt.stage, opt.action_type)
    local_model = ActorCritic(num_states, num_actions)
    local_model.eval()
    state = torch.from_numpy(env.reset())
    done = True
    curr_step = 0
    actions = deque(maxlen=opt.max_actions)
    while True:
        curr_step += 1
        if done:
            local_model.load_state_dict(global_model.state_dict())
        with torch.no_grad():
            if done:
                h_0 = torch.zeros((1, 512), dtype=torch.float)
                c_0 = torch.zeros((1, 512), dtype=torch.float)
            else:
                h_0 = h_0.detach()
                c_0 = c_0.detach()
        logits, value, h_0, c_0 = local_model(state, h_0, c_0)
        policy = F.softmax(logits, dim=1)
        action = torch.argmax(policy).item()
        state, reward, done, _ = env.step(action)
        env.render()
        actions.append(action)
        if curr_step > opt.num_global_steps or actions.count(actions[0]) == actions.maxlen:
            done = True
        if done:
            curr_step = 0
            actions.clear()
            state = env.reset()
        state = torch.from_numpy(state)

再次,我们进行设置和初始化,并在评估模式(实际上,在推理模式下,模型在此过程中不会更新)下加载本地的 ActorCritic 模型。此时,我们开始循环,从全局模型中加载最后一步的权重。对于某个状态,我们计算每个动作的概率,并选择概率最高的动作。注意,在训练过程中,我们进行了动作的采样;而在评估模式下,我们则采用贪婪策略选择动作。我们与环境交互,渲染游戏,进行动作跟踪,并检查代理是否陷入困境或无限重复相同的动作。如果代理超过最大步数或陷入困境,则剧集结束,我们重置状态。此函数评估训练代理的性能,渲染游戏玩法,以便用户可以观察代理学习玩超级马里奥兄弟的情况。它确保策略有效,并提供视觉反馈。

运行脚本,我们可以看到训练是并行进行的:

图 8.29 – 脚本运行截图

图 8.29 – 脚本运行截图

您可以在此处查看视频:www.youtube.com/watch?v=YWx-hnvqjr8

总结来说,我们使用了几个脚本来实现动作-评论家算法(A3C 方法)的一个变体。这种方法涉及并行训练多个代理以探索环境、收集经验并异步更新共享的全局模型。换句话说,我们使用了一个允许我们加快训练速度并学习更鲁棒模型的变体,因为它从不同的代理那里检索不同的经验。为了更清晰的组织,我们将过程分解为几个脚本,然后将它们链接成一个单一的脚本(过程脚本)。我们定义了具有两个组件的公共提取器,以便我们可以节省一些计算。此外,我们使用 LSTM 来处理一个状态与另一个状态之间存在的时序依赖性。我们必须修改我们的优化器,因为我们需要共享内存来处理多个进程以更新全局模型。异步训练确实具有更高的复杂性,其中每个代理都需要访问和更新全局模型。之后,我们定义了如何通过收集一些经验来训练我们的模型。收集经验后,我们更新模型权重,计算损失并执行反向传播。定期地,我们同步全局和局部模型,对全局模型进行更新。之后,我们定义了如何使用全局模型的参数来评估我们的代理。代理使用学到的策略来玩游戏。

这些脚本由于采用了 A3C 方法,因此能够实现高效的并行训练。实际上,我们可以使用多个代理并行地探索环境、收集经验,然后导致全局模型更新。使用并行系统使得代理探索环境的不同部分,导致更多样化的经验,从而产生更通用的策略。一般来说,这是有利的,因为在视频游戏中可能需要不同的策略。同样地,我们添加了熵损失来鼓励探索并防止代理陷入次优策略。该脚本旨在高效利用资源,减少计算,并实现快速训练(我们没有添加经验回放缓冲区以节省内存,从而消耗更少的 RAM)。使用全局模型确保一个代理学到的知识立即对所有代理可用;这通常促进快速收敛。

选择在线策略学习方法如 A3C 可能会导致策略更新的高方差。这种方差随后可能被异步性放大,这可能会使得在运行之间获得一致的结果变得困难。实际上,异步方法引入了非确定性,意味着结果可能在运行之间有显著差异。这使得过程更不可预测,并复杂化了超参数的选择(这就是为什么我们提供了默认参数,尽管可以尝试调整它们)。虽然我们已经尝试优化此脚本的资源消耗,但整个过程仍然资源密集(就像 RL 一般)。

A3C 主要依赖于基于 CPU 的并行性;然而,采用对 GPU 友好的方法可以显著提高训练效率。例如 PPO 这样的算法可以利用 GPU 优化训练过程。有效使用 GPU 可以更高效地进行批量处理,允许积累经验并对模型进行批量更新。对于有兴趣探索基于 GPU 优化方法的读者,以下是一些潜在的想法:

  • 测试不同的超参数并改变它们的值,以更好地理解它们的影响。在脚本中,您可以轻松地设置和更改超参数。我们邀请您测试 lambda (λ) 以找到偏差和方差之间的更好平衡。

  • 尝试 PPO。PPO 是 A3C 的一个流行替代方案,它利用多个 epoch 的 mini-batch 更新。正如我们所见,它是一种促进稳定性且在许多情况下表现良好的算法。它也不需要很多超参数,默认参数通常效果良好。

  • 采用同步 A2C,因为它是一个更简单、同步的 A3C 版本。这种方法并行收集经验,并使用批量进行更新。它通常较慢但更容易调试。

本项目中展示的模型可以应用于其他几个视频游戏,展示了 RL 算法如何解决实际任务。

LLM 与 RL 模型之间的交互

RL 算法对于能够导航复杂环境、优化策略和做出决策的智能体至关重要,在机器人技术和视频游戏等领域取得了成功。另一方面,LLMs 对自然语言处理(NLP)产生了重大影响,使机器能够理解人类语言和指令。尽管可以想象潜在的协同效应,但到目前为止,这两种技术是并行发展的。然而,近年来,随着对 LLMs 兴趣的增加,这两个领域越来越多地交叉。在本节中,我们将讨论 RL 和 LLMs 之间的交互。

我们可以有三种交互情况:

  • RL 增强 LLM:使用 RL 增强一个 LLM 在一个或多个 NLP 任务中的性能

  • LLMs 增强 RL:使用 LLMs 训练一个执行非必要是 NLP 任务的 RL 算法

  • RL 和 LLMs:结合 RL 模型和 LLMs 来规划技能集,而不使用任一系统来训练或对另一个系统进行微调

让我们详细讨论这些内容。

RL 增强的 LLMs

我们已经在第三章中讨论了对齐和提示工程。然后,RL 被用于微调、提示工程和 LLMs 的对齐。如第三章中提到的,LLMs 被训练来预测序列中的下一个单词,导致 LLMs 的训练目标与人类价值观之间存在不匹配。这可能导致 LLMs 生成带有偏见或其他不安全内容的文本,同样也可能在遵循指令方面表现不佳。对齐的作用是将模型重新对齐到人类价值观,或者使 LLM 在更安全的部署中更有效。最广泛使用的技术之一是从人类反馈中进行强化学习(RLHF),其中奖励是从人类偏好中推断出来的,然后用于训练 LLM。这个过程遵循三个步骤:收集人类反馈数据,在此数据上训练奖励模型,以及使用 RL 对 LLM 进行微调。通常,最受欢迎的 RL 算法选择是 PPO 或其衍生方法。实际上,我们不希望我们的对齐模型与原始模型有显著差异,这是 PPO 保证的。

与 LLMs 的交互通过提示进行,提示应浓缩我们希望 LLM 完成的任务的全部指令。一些研究工作集中在使用 RL 来设计提示。提示优化可以表示为一个 RL 问题,其目标是将人类知识融入其中,从而生成可解释和可适应的提示。代理被用来构建查询依赖和优化的提示。一个人也可以训练一个策略网络来生成期望的提示,其优点是提示通常可以在 LLMs 之间迁移。这种方法的一个有趣方面是,其中一些优化提示在语法上是“胡言乱语”,这表明对于任务的优质提示不一定需要遵循人类语言模式。

LLM 增强的 RL

LLM 增强的 RL指的是使用预训练的 LLM 的多模态信息处理、生成、推理或其他高级认知能力来辅助 RL 代理的方法。换句话说,与传统 RL 的不同之处在于使用了 LLM,并以某种方式利用其知识和能力。以某种形式添加 LLM 具有双重优势:首先,LLM 拥有推理和规划技能,这有助于提高学习效率,其次,它具有更强的泛化能力。此外,LLM 在预训练阶段获得了广泛的知识,这些知识可以跨领域和任务进行迁移,从而更好地适应尚未见过的环境。通常,预训练的模型无法扩展其知识或获取新的能力(持续学习是深度学习的开放挑战),因此使用大量知识训练的模型可以帮助这一方面(LLMs 是通才,在记忆中拥有不同领域的海量信息)。

LLM 可以插入到经典 RL 系统(代理与环境交互并接收反馈)的多个点。LLM 可以集成以提取信息、重新处理状态、重新设计奖励、做出决策、选择动作、解释策略、分析世界相似性等。

图 8.30 – 经典代理-环境交互中 LLM 增强的 RL 框架(img/B21257_08_30.jpg)

图 8.30 – 经典代理-环境交互中 LLM 增强的 RL 框架(arxiv.org/pdf/2404.00282)

因此,LLM 可以作为信息处理器、奖励设计师、决策者和生成器在系统中使用。

信息处理器

当一个任务需要文本信息或视觉特征时,代理同时理解信息和优化策略可能会很复杂。正如我们之前看到的,卷积神经网络可以用来处理图像,使模型能够与视频游戏或棋盘游戏交互。在聊天机器人的情况下,我们可以使用一个理解语言的模式。或者,我们可以在不直接使用语言模型的情况下,使用 LLM 提取特征,使代理能够更快地学习。LLMs 可以作为好的特征提取器,从而降低信息的维度和复杂性。或者 LLMs 可以将自然语言翻译成代理能够理解的特定形式化语言。例如,在机器人案例中,不同用户的自然语言可能不同且不统一,这使得代理难以学习。LLM 可以将指令转换成标准、形式化的语言,使代理更容易学习。

一个广泛的预训练模型学习数据的表示,然后可以用于后续的应用。因此,一个模型可以用来提取我们可以用来训练智能体的数据表示。一个 LLM 可以被冻结使用(即,不需要进一步训练)来提取环境的压缩历史表示。一些研究使用 LLM 来总结提供给智能体的过去视觉观察,这样我们就可以为智能体提供一个记忆。使用冻结的模型显然是最简单的替代方案,但当智能体在现实世界中部署时,由于现实世界的变化与训练环境之间的差异,性能可能会迅速下降。因此,我们可以对智能体和 LLM 进行微调。使用特征提取器(一个 LLM 或其他大型模型)使智能体更容易学习,因为这些特征对环境变化(亮度、颜色等变化)的鲁棒性更强,但另一方面,它们有额外的计算成本。

LLM 的能力可以用来使任务更清晰。例如,自然语言中的指令可以通过 LLM 调整为对智能体更清晰的指令集(例如,在玩视频游戏时,任务的文本描述可以转换为一套关于如何移动角色的指令)。LLM 还可以用来将智能体的环境翻译成可用的信息。这些方法特别有前景,但目前范围有限。

图 8.31 – LLM 作为信息处理器(img/B21257_08_31.jpg)

图 8.31 – LLM 作为信息处理器(arxiv.org/pdf/2404.00282)

奖励设计师

当问题知识可用,或者当奖励可以通过一个清晰且确定性的函数定义(例如游戏得分或胜负条件)时,设计奖励函数是直接的。例如,在 Atari 游戏(或其他游戏)中,很容易绘制出奖励函数(例如,胜利代表一个积极信号,失败代表一个消极信号)。在许多应用中,这是不可能的,因为任务既长又复杂,奖励分散,等等。在这种情况下,LLM 固有的知识(在预训练期间获得的知识、编码能力和推理技能)可以用来生成奖励。它可以间接使用(隐式奖励模型)或直接使用(显式奖励模型)。例如,用户可以在提示中定义期望的行为,LLM 可以在训练期间评估智能体的行为,提供奖励和惩罚。因此,你可以使用 LLM 的直接反馈,或者 LLM 可以生成奖励函数的代码。在第二种方法中,函数可以在训练期间由 LLM 修改(例如,在智能体获得一些技能后,使其更难获得奖励)。

一个 LLM 可以是一个隐式奖励模型,它根据任务描述提供奖励(或辅助奖励)。实现这一点的技术之一是直接提示,其中向 LLM 提供指令以评估代理的行为或决定奖励。这些方法可以模拟人类反馈以实时评估代理的行为。或者,可以使用对齐分数,例如,在动作结果和目标之间(换句话说,评估预期结果与现实之间的相似性)。在某些方法中,使用语言指令和代理的图像观察之间的对比对齐,从而利用多模态模型。显然,对齐人类意图和 LLM 奖励生成的过程并不容易。可能会有歧义,系统并不总是能够处理低质量的指令,但这似乎是一条有希望的途径。

显式奖励模型利用了 LLM 生成代码的能力,从而生成一个函数(使 LLM 的决策和奖励生成过程更加透明)。这允许自动生成子目标的函数(例如,让机器人通过使用 LLM 翻译成奖励函数的高级指令来学习低级任务)。这种方法的主要局限性是 LLMs 的常识推理限制。LLMs 无法进行真正的推理或真正的泛化,因此它们受限于预训练期间所见的内容。在预训练期间,LLMs 没有看到高度专业化的任务,因此限制了这些方法在选定任务集上的适用性。添加上下文和附加信息可以缓解这个问题。

图 8.32 – LLM 作为奖励设计师 (https://arxiv.org/pdf/2404.00282)

图 8.32 – LLM 作为奖励设计师 (arxiv.org/pdf/2404.00282)

决策者

由于在许多情况下 RL 存在样本和探索效率低下的问题,LLMs 可以在决策中使用,从而帮助选择行动。LLMs 可以用来减少某个状态下的动作集合(例如,当存在许多可能的动作时)。减少动作集合减少了探索空间,从而提高了探索效率。例如,LLM 可以用来训练机器人在世界中的行动,减少探索时间。

变换器(或其衍生模型)在强化学习(RL)中显示出巨大的潜力。其背后的想法是将这些问题视为序列建模问题(而不是试错)。因此,LLM 可以被看作是一个决策模型,它必须决定一系列问题(正如我们在第二章中提到的,变换器是在一系列问题上进行训练的,因此对一系列状态做出决策符合其训练)。一个 LLM 可以被微调以利用模型的内部表示。实际上,通过这种方式,我们利用从 LLM(使用大量文本进行训练,LLM 已经积累了大量可以应用于任务的已知知识)学习到的表示来决定一个动作。使用先验知识减少了数据收集和探索的需求(因此,提高了样本效率),并使系统在长期奖励或稀疏奖励环境中更加高效。一些研究表明,不仅从 LLM 学习到的知识可以转移到其他模型,而且整个系统在不同基准上的性能也得到了提高。此外,视觉-语言模型可以用来使系统能够适应多模态环境。将 LLM 用作决策者仍然计算成本高昂(即使仅在推理中使用且不需要微调)。因此,当前的研究正致力于尝试降低这些方法的计算成本。

或者,LLM 可以通过生成合理的动作候选或专家动作来引导智能体选择动作。例如,在基于文本的游戏等环境中,动作空间非常大,而目前只有一小部分动作可用,因此智能体可以通过广泛的试错来学习;然而,这种探索效率非常低。LLM 可以通过理解任务来生成动作集,从而减少动作空间。这使得减少探索并使其更有效率、收集更多奖励和加快训练成为可能。通常,在这些方法中,我们有一个生成动作集的 LLM 和另一个生成候选动作 Q 值的神经网络。相同的方法已经扩展到需要遵循人类指令的机器人,其中 LLM 生成可能的动作。这种方法由于 LLM 的偏差和局限性的继承而受到限制(因为 LLM 决定动作空间并根据其知识和偏差生成它)。

图 8.33 – 作为决策者的 LLM (https://arxiv.org/pdf/2404.00282)

图 8.33 – 作为决策者的 LLM (arxiv.org/pdf/2404.00282)

生成器

基于模型的 RL 依赖于世界模型来学习环境的动态并模拟轨迹。LLM 的能力可以是生成准确的轨迹或解释策略选择。

LLM 具有固有的生成能力,使其可以用作生成器。然后,LLM 可以用作世界模型模拟器,系统生成智能体用于学习和规划的准确轨迹。这已经在视频游戏中得到应用,其中 LLM 可以生成轨迹,从而减少智能体学习游戏所需的时间(提高样本效率)。LLM 的生成能力还可以用于预测未来。尽管前景看好,但仍然难以将 LLM 的抽象知识与环境现实对齐,限制了其生成能力的影响。

另一种有趣的方法是使用一个大型语言模型(LLM)来解释强化学习(RL)系统的策略。可解释的强化学习(XRL)是可解释机器学习和强化学习交叉领域的一个新兴子领域。XRL 旨在向人类清晰地解释智能体的行为。然后,LLM 可以用来用自然语言解释智能体为何做出某种决策或对环境变化做出某种反应。作为一个策略解释器,给定一个状态和一个动作,LLM 应该解释智能体的行为。这些解释应该对人类来说是可理解的,从而允许检查智能体的安全性。当然,解释的质量取决于 LLM 理解环境特征表示和政策隐含逻辑的能力。使用领域知识或例子来提高对复杂策略(尤其是对复杂环境)的理解是困难的。

图 8.34 – LLM 作为生成器 (https://arxiv.org/pdf/2404.00282)

图 8.34 – LLM 作为生成器 (arxiv.org/pdf/2404.00282)

LLM 增强的 RL 可以在各种应用中发挥作用:

  • 机器人技术:使用 LLM 可以提高人类与机器人之间的交互,帮助机器人更好地理解人类需求或人类逻辑,并提高它们的决策和规划能力。

  • 自动驾驶:在自动驾驶中,强化学习用于在复杂环境中做出决策,这些环境复杂,需要分析来自不同传感器(视觉、激光雷达、雷达)的输入,并考虑上下文信息(交通法规、人类行为、意外问题)。LLM 可以提高处理和整合这种多模态信息的能力,更好地理解指令,并改善目标和奖励(例如,设计考虑安全、乘客舒适度和发动机效率的奖励函数)。

  • 医疗建议:在医疗保健中,强化学习用于学习建议和推荐。LLM 可以用于其广泛的知识和能够分析大量患者数据和医疗数据的能力,加速智能体的学习过程,或为更好的学习提供信息。

  • 能源管理:强化学习用于提高能源的使用、运输、转换和储存。此外,它预计将在未来的技术(如核聚变)中发挥重要作用。LLM 可用于提高样本效率、多任务优化等。

尽管有这些机会,但在强化学习中使用 LLM 也存在一些局限性。第一个挑战是 LLM 增强的 RL 范式高度依赖于 LLM 的能力。LLM 存在偏差并且可能产生幻觉;智能体随后从 LLM 继承了这些问题。此外,LLM 还可能误解任务和数据,尤其是在它们复杂或嘈杂时。此外,如果任务或环境没有在它们的预训练中表示,LLM 在适应新环境和任务时会有问题。为了限制这些影响,已经提出了使用合成数据、微调模型或使用持续学习的方法。持续学习可能允许模型适应新任务和新环境,而不会忘记模型之前学到的内容。然而,到目前为止,持续学习和灾难性遗忘仍然是深度学习中的开放性问题。

此外,添加一个大型语言模型(LLM)会带来更高的计算成本(在训练和推理过程中),以及延迟时间的增加。可以使用几种技术来降低这种计算成本,例如量化、剪枝或使用小型模型。一些方法使用专家混合,允许条件计算、变换器变体(状态空间模型)、缓存策略等。

最后,不应忘记使用 LLM 也引发了道德、法律和安全问题。我们在第三章中看到的问题也适用于这些系统。例如,数据隐私和知识产权仍然是敏感领域(如医疗保健或金融)应用中的开放性问题。

关键要点

由于本章在理论方面内容密集,我们决定添加一个小结部分。本章介绍了强化学习(RL)作为使智能体通过与环境交互并通过试错来学习的一种核心方法,类似于人类通过行动、观察结果和调整行为来学习的方式。RL 与监督学习不同,它侧重于从奖励而非标记数据中学习,并且特别适合具有延迟反馈和演变决策序列的任务。

强化学习是一种机器学习范式,其中智能体通过与环境的交互来学习做出决策,以最大化累积奖励。它通过试错来学习,平衡探索(尝试新动作)和利用(使用已知策略)。

总结来说,我们有以下几类方法:

  • 无模型与 基于模型 的强化学习:

    • 无模型方法(例如,DQN、REINFORCE)直接从交互中学习,而不对环境进行建模。它们更简单且更具可扩展性。

    • 基于模型的方法使用内部模型来模拟结果并提前规划。它们更有效率,适用于规划至关重要的环境,但设计和计算更困难。

  • 策略方法与离策略方法的比较:

    • 离策略方法从当前策略生成的数据中学习(例如 REINFORCE、PPO),这使得它们更稳定但样本效率较低。

    • 离策略方法(例如 DQN)可以从过去或替代策略中学习,从而提高样本效率和探索灵活性。

  • 讨论的主要算法:

    • Q-Learning 和 DQN:使用查找表或神经网络学习价值函数。

    • REINFORCE:使用随机策略的基本策略梯度方法。

    • PPO:通过剪辑策略更新来平衡稳定性和性能。

    • Actor-Critic:结合价值估计和政策学习,以实现更稳健的更新。

    • AlphaZero:将深度学习与蒙特卡洛树搜索相结合,用于复杂游戏中的基于自我对弈的策略优化。

  • 实际应用案例:

    • 游戏:例如 AlphaZero 和 DQN 这样的强化学习代理已经掌握了围棋、象棋和 Atari 游戏等。

    • 机器人技术:强化学习允许机器人通过模拟和现实世界的反馈学习复杂的运动和交互策略。

    • 自动驾驶汽车:强化学习使代理能够在动态和不确定的环境中学习驾驶策略。

    • 优化和控制:应用于金融、医疗保健、物流和工业自动化中的顺序决策。

摘要

在前几章中,主要问题是如何找到信息以及如何有效地将信息传递给一个语言模型(LLM)。在这种情况下,模型是一个被动代理,接收信息并做出响应。在本章中,我们试图摆脱这种范式,转向一个理念,即代理探索环境,通过这种探索学习,执行动作,并从环境提供的反馈中学习。在这种观点下,模型是一个主动组件,与环境互动并可以对其进行修改。这种观点也与人类学习的方式更为接近。在我们对外部世界的探索中,我们接收到的反馈引导我们的学习。尽管世界的大部分内容已经在文本中被记录下来,但现实世界不能简化为文本描述。因此,代理在与世界互动之前无法学习某些知识和技能。强化学习是人工智能的一个领域,它关注代理与环境之间的互动以及它如何从中学习。

因此,在本章中,我们介绍了强化学习(RL)的基础知识。在第一部分,我们讨论了 RL 系统的基本组成部分(代理、环境、奖励和动作)。然后,我们讨论了 RL 的主要问题,即如何平衡探索和利用。实际上,代理有一个目标(完成任务),但通过探索来学习如何完成这个任务。例如,我们在多臂老丨虎丨机示例中看到,贪婪模型的表现不如探索所有可能性的模型。当我们定义代理来解决复杂问题,如解决视频游戏时,这一原则仍然是基本的。为了解决复杂任务,我们引入了神经网络(深度强化学习)的使用。我们看到了不同类型的算法具有不同的优缺点,并看到了我们如何将其中之一设置为在经典视频游戏中获胜。一旦我们训练了我们的模型,我们就讨论了 LLM 和 RL 领域如何日益交叉。这样,我们就看到了两个领域的优势如何协同作用。

从本章开始,重点将更加应用性。我们将看到代理通常如何完成任务。在接下来的章节中,代理将主要是一个 LLM,它将使用工具执行动作和完成任务。因此,代理的选择将不是采取哪个动作,而是选择哪个工具来完成一个任务。尽管 LLM 代理与环境交互,但一个主要区别是不会有训练。训练 LLM 是一个复杂任务,因此在这些系统中,我们尽量减少训练。如果在之前的章节(5–7)中,我们试图利用 LLM 的理解能力,那么在接下来的章节中,我们将尝试利用 LLM 与环境或与其他代理交互的技能——这些技能无论如何都是可能的,因为 LLM 可以理解任务和指令。

进一步阅读

第三部分:创建解决复杂场景的复杂 AI

本最后一部分专注于将前几章中介绍的部分组件组装起来,以构建完全成熟、适用于生产的 AI 系统。它从单代理和多代理系统的设计和编排开始,其中 LLMs 与工具、API 和其他模型协作,以解决复杂的多步骤任务。该部分随后引导您了解使用现代工具(如 Streamlit、异步编程和 Docker 等容器化技术)构建和部署 AI 代理应用程序的实际方面。最后,本书以对 AI 代理未来的展望结束,讨论其在医疗保健和法律等行业的跨行业影响,以及未来面临的伦理和技术挑战。本部分使您能够从实验过渡到现实世界的部署,为参与下一波智能系统做好准备。

本部分包含以下章节:

  • 第九章**,创建单代理和多代理系统

  • 第十章**,构建人工智能代理应用

  • 第十一章**,未来的展望

第九章:创建单代理和多代理系统

在前面的章节中,我们讨论了许多可以与 LLMs 相关联的组件或工具,以扩展其功能。在第五章和第六章中,我们详细讨论了如何使用外部记忆来丰富上下文。这允许模型获得额外的信息,以便在它不知道答案时(当它在预训练期间没有看到文档或它涉及训练日期之后的信息)回答用户的问题。同样,在第七章中,我们看到了知识图谱可以用来扩展模型的知识。这些组件试图解决 LLMs 最令人头疼的限制之一,即幻觉(模型产生的非事实正确的输出)。此外,我们还看到,使用图可以使模型进行图推理,从而增加新的能力。

在第八章中,我们看到了强化学习(RL)和 LLMs 的交集。与 LLMs 相关的一个问题是它们可能会产生有害内容(如偏见或有害内容或错误信息)。RL 算法使我们能够使模型的行为与人类偏好保持一致,从而降低有害内容的风险。

我们可以使用类似的方法使模型更擅长执行任务或遵循指令。在未来,这些强化学习算法可能有助于克服 LLMs 的一个重要限制:缺乏持续学习。

正如我们将看到的,工具的定义相当广泛。实际上,任何软件或算法都可以是工具。正如我们在前面的章节中已经看到的,LLMs 可以执行代码或连接到应用程序编程接口(APIs)。但这意味着它们也可以调用其他模型来执行它们自己无法完成的任务。

在任何情况下,所有这些元素都为所谓的代理革命奠定了基础,在这个革命中,LLM 可以与环境交互并在现实世界中执行任务(无论是互联网还是未来,超越计算机的限制)。

在本章中,我们专注于大型语言模型(LLMs),其各种工具,以及如何将这些工具结合起来与环境交互。我们将从自主代理的定义开始,然后继续讨论工具(APIs、模型等)是什么以及它们如何被组织。我们将看到使用提示工程技巧(我们在第三章中讨论过)如何使我们能够创建不同类型的代理。之后,我们将讨论文献中先前使用的一些策略,这些策略用于将 LLM 连接到其工具。

这将使我们能够详细了解一些技术限制和挑战是如何被解决的。然后,我们将详细讨论 HuggingGPT(一个连接到数百个模型的 LLM),这是代理创建的一个转折点。我们将看到 HuggingGPT 如何允许 LLM 使用其他专家模型解决复杂任务。然后,我们将看到如何创建多代理平台,而不是单个代理。不同代理的交互将使我们能够解决越来越复杂的问题。此外,我们将看到这些方法如何应用于复杂领域,如医疗保健、化学和法律。然后,我们将使用 HuggingGPT 将我们所学的内容付诸实践。接下来,我们将通过一个多代理平台扩展这一概念,这将使我们能够理解现代系统是如何工作的。

一旦我们了解了代理或多代理的工作方式,我们将详细讨论新兴的新商业模式,例如软件即服务(SaaS)、模型即服务(MaaS)、数据即服务(DaaS)和结果即服务(RaaS)或成果即服务(OaaS)。正如我们将在本章中看到的,这些商业模式各有优缺点。

在本章中,我们将涵盖以下主题:

  • 自主代理简介

  • HuggingGPT 和其他方法

  • 与 HuggingGPT 一起工作

  • 多代理系统

  • SaaS、MaaS、DaaS 和 RaaS

技术要求

本章中的代码需要使用 GPU。特别是对于使用 HuggingGPT 的部分,需要 GPU 和硬盘驱动器上的大量空间(将下载多个模型,包括扩散模型。为此,将需要使用 Git 大型文件存储(LFS),它允许通过 Git 下载大文件)。应安装 Anaconda 以获取各种库(必要的库将在安装过程中直接设置)。对于没有这些资源的读者,使用 HuggingGPT 在网络上部分展示了如何在网上使用 HuggingGPT。对于本地使用 HuggingGPT,需要 OpenAI 令牌,而对于网络使用,也需要 Hugging Face 令牌。多代理系统基于 Python 库(NumPy、scikit-learn、SentenceTransformers 和 Transformers)。

HuggingGPT 应在 GPU 上运行。多代理系统应在 GPU 上运行,但也可以在 CPU 上运行;然而,这被高度不建议。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr9。

自主代理简介

在人工智能的背景下,自主代理指的是可以独立执行任务或做出决策的系统或实体,而无需人类干预。这些代理被设计为感知其环境,对其进行分析,根据其目标做出决策,并据此采取行动以实现这些目标。自主代理被认为是通往通用人工智能(AGI)的重要一步,AGI 预计将进行自主规划和行动。

使用 LLMs 作为代理的主要原因在于 LLMs 已经显示出一些推理和规划能力。LLMs 使用推理来解释输入,进行推理,并做出决策(显示出一定程度的演绎、归纳和类比推理)。这使得 LLMs 能够将一般规则应用于特定情况(演绎推理),从例子中学习模式(归纳推理),并从不完全数据中推断解释(类比推理)。此外,LLMs 能够通过串联想法进行逐步推理,从而使其能够解决方程或调试代码。解决某些问题(如数学问题)需要遵循一系列步骤。本质上,一个 LLM 必须经常将任务分解成一系列动作,预测这些动作的结果,并根据结果调整其行为。然而,这些能力仅限于用户提供的上下文或预训练期间获得的知识,对于医学或金融等领域,这不足以解决大多数问题。因此,对此限制的自然反应是扩展 LLM 的能力,使用外部工具,或者将 LLM 连接到外部环境。

因此,一些研究和研究的目的是通过一系列工具来扩展大型语言模型(LLMs)的能力。这些工作和由此产生的库试图为 LLMs 配备人类能力,例如记忆和规划,使它们的行为像人类一样,并有效地完成各种任务。

随着 LLMs 能力的不断发展,对这些代理的兴趣也在增长,已经发表了众多文章和框架。

图 9.1 – 对 LLM 自主代理的兴趣日益增长 (https://arxiv.org/pdf/2308.11432)

图 9.1 – 对 LLM 自主代理的兴趣日益增长 (arxiv.org/pdf/2308.11432)

在构建这些类型的系统时,首先要考虑的是架构的设计以及如何使用它来执行任务。自主代理必须执行不同的角色,感知环境,并从中学习。架构的目的是帮助 LLM 最大化其能力,以便用作代理。为此,已经开发出几个模块,可以分为四个主要组:配置文件、记忆、规划和行动。

图 9.2 – 构建基于 LLM 的自主代理的可能模块 (https://arxiv.org/pdf/2308.11432)

图 9.2 – 构建基于 LLM 的自主代理的可能模块 (arxiv.org/pdf/2308.11432)

让我们更详细地逐一介绍这些内容:

  • 配置文件模块:通常,代理在特定的角色(也称为角色扮演)中执行任务,例如编码者、领域专家、教师或助手。配置文件模块负责在给定的 LLM 特定提示中定义这些角色(特征、角色、心理和社会信息,以及与其他代理的关系)。然后,这些配置文件可以是手写的(手写配置文件是由开发者或领域专家手动制作的个人或角色定义);例如,对于软件开发系统,我们可以创建不同的工作角色(“你是一名负责代码审查的软件工程师”)。手写配置文件允许高度的控制、丰富上下文,并且可以高度特定于领域(解决细微差别、软技能、复杂知识)。尽管手写方法非常灵活,但它耗时且可扩展性有限。因此,一些研究探索了 LLM 自动生成配置文件的系统(使用少量示例、规则和模板,或特定外部数据集作为工作描述)。这种方法具有更高的可扩展性和对不同情况的适应性(特别是如果系统需要动态或如果收到用户反馈)。然而,另一方面,控制程度较低(系统失去了细微差别和深度,存在变得通用的风险),质量参差不齐(取决于提示工程技术,一些示例可能质量较差),并且仍然需要人工验证。

  • 记忆模块:记忆模块存储系统从环境或其他来源感知到的信息;这些记忆随后有助于未来的行动。专门的记忆组件也可以是复杂的,并受到人类认知的启发,具有针对感知、短期或长期信息的组件。常见的记忆随后被输入到系统提示中(因此 LLM 的上下文长度是可用于代理的记忆的限制)。例如,完成任务所需的与用户的聊天历史。作为另一个例子,协助游戏开发的代理将具有刚刚发生的事件和其他描述作为短期记忆。混合记忆是一种扩展记忆的方法,其中过去的事件和思想被保存并再次找到,以促进代理的行为。混合记忆结合了短期(在 LLM 上下文中)和长期(外部)记忆,以扩展代理的能力,使其超越 LLM 的上下文窗口。这些思想、对话或其他信息可以通过 RAG 或其他系统(数据库、知识图谱等)保存。当需要时,相关信息被检索并注入到 LLM 提示中,使代理能够根据先前知识行事,而不超过上下文限制。例如,在 RAG 中,搜索机制根据当前查询检索相关的文档或记忆片段,使响应在时间上更加知情和一致。此外,此模块应涵盖三个操作:记忆读取(提取对代理行动有用的信息)、记忆写入(存储可能对未来有用的环境信息,同时避免重复和内存溢出),以及记忆反思(评估和推断更抽象、复杂和高级的信息)。具体来说,记忆读取检索信息以支持代理的决策(增加上下文的连续性和一致性),记忆写入允许保存对代理与环境交互有用的信息(从而减少冗余并允许克服不可编辑记忆的限制),而记忆反思允许从存储信息的分析中得出见解,从而允许调整行为以实现目标。

  • 规划模块:规划模块通常用于将复杂任务分解成更易于管理的任务,以使大型语言模型(LLM)的行为更加合理、强大和可靠。规划模块可以包含或不包含反馈。

    在没有反馈的规划中,代理在执行行动后不会收到影响其未来行为的反馈。在单路径推理中,任务被分为几个中间步骤,这些步骤以级联序列连接。思维链(CoT)推理通常用于为这种策略制定逐步计划。相比之下,多路径推理涉及一个树状结构,其中每个中间步骤都可以分支成多个后续步骤。这些方法通常利用自洽思维链(CoT-SC)或思维树(ToT)框架,以评估所有中间步骤以确定最佳策略。该树甚至可以与复杂的策略相结合,如蒙特卡洛树搜索(MCTS)或外部规划器。

    带反馈的规划主要用于长期任务,在这种情况下,从开始就难以生成有效的计划,或者动态可能发生变化。因此,你可以结合来自环境和观察的反馈。例如,ReAct 框架使用思考-行动-观察三元组。另一种选择是使用人类反馈或另一个模型来提高代理的规划能力。

图 9.3 – 单路径和多路径推理策略的比较(img/B21257_09_03.jpg)

图 9.3 – 单路径和多路径推理策略的比较(arxiv.org/pdf/2308.11432)

  • 动作模块:动作模块负责将规划转化为特定的结果;然后该模块负责交互。一般来说,该模块专注于任务的执行以及具有特定目标的行为。该模块还负责与其他代理(如果存在)通信、探索环境、寻找必要的记忆以及执行计划。为了实现这些目标,LLM 可以使用在预训练阶段从 LLM 获得的知识或外部工具(外部模型、API、数据库或其他工具)。预训练知识允许 LLM 使用学习到的信息执行许多任务,例如生成文本、回答问题或根据先前数据做出决策。然而,对于更动态、实时或专业的任务,动作模块使用外部工具,如 API、数据库、软件应用程序或其他模型。这些工具使代理能够访问最新信息、操作数据、执行计算或在外部系统中触发操作。预训练知识和外部工具共同使代理能够与环境进行有意义的交互,实现目标,并根据其行动的结果进行适应。模型的行为对环境或模型内部状态有影响,并由该模块评估和考虑。

除了系统架构之外,我们还应该考虑开发更好代理的策略。通常,最常用的策略之一是对模型进行微调。微调通过将通用 LLM 适应特定任务、领域或行为目标,在提高代理性能方面发挥着关键作用。它有助于使模型与人类价值观(安全性)保持一致,提高指令遵循性,或在教育或电子商务等领域进行专业化。在大多数情况下,用于特定任务的数据集都是人工标注的。正如我们在第三章中讨论的那样,这可能是出于安全原因(与人类价值观保持一致)、使其更易于遵循指令(指令调整)或训练特定领域或任务。以 WebShop 为例(arxiv.org/pdf/2308.11432),论文的作者们收集了来自 amazon.com 的 120 万个世界产品,并创建了一个模拟的电子商务网站。之后,他们收集了网站上的用户行为(当用户在网站上浏览和执行操作时,他们的行为会被记录),从而创建了一个专门用于帮助产品选择的代理的微调数据集。或者,在 EduChat 的例子(arxiv.org/pdf/2308.11432)中,为了创建一个用于教育场景的代理,作者们收集了一个覆盖各种教育场景的标注数据集(数据集由心理学家等专业人士评估和编辑)。

收集这些数据集成本高昂,并且在某些情况下需要专业的技术人员。因此,一个替代方案是使用大型语言模型(LLM)来标注数据集。当采用这种方法时,质量和成本之间存在权衡:数据集不如人工标注的好,但成本大幅降低。例如,在 ToolBench(一个将 LLM 连接到 API 的代理系统)中,该工作的作者们(arxiv.org/pdf/2308.11432)收集了超过 16,000 个真实世界的 API,然后使用 ChatGPT 对此数据集进行标注。然后,他们在该数据集上微调了 LLaMA。微调后的模型在使用这些 API 时表现更出色。

图 9.4 – ToolBench 的构建(img/B21257_09_04.jpg)

图 9.4 – ToolBench 的构建(arxiv.org/pdf/2307.16789)

或者,你可以收集大量未标注的数据,这样模型就可以在微调过程中自行找出。例如,Mind2Web 收集了大量用于网络浏览的数据(arxiv.org/abs/2306.06070)。

标注数据集和自标注数据集之间的权衡在于,LLM 标注的数据可能缺乏人类标注的准确性、细微差别或可靠性,这可能会影响性能。然而,它允许更广泛的覆盖范围和更快的迭代。在实践中,结合这两种方法——使用 LLM 进行大量标注,而人类进行验证或高风险任务——在质量和成本之间提供了平衡,使微调更加容易,同时仍然增强了代理的能力。

由于与模型的交互通常是通过提示进行的,因此许多开发者简单地使用提示工程,而不需要微调。其理由是必要的知识已经存在于 LLM 的参数中,我们希望使用一个提示,使模型能够最大限度地利用它。其他方法添加了充当评论家的代理、进行辩论的其他代理或其他变体。

我们迄今为止所看到的内容使我们能够理解什么是自主代理以及它是如何构成的。正如我们所见,一个代理的核心是一个 LLM,以及围绕它的复杂生态系统,这些元素可以根据研究者的选择进行组合。在接下来的章节中,我们将详细探讨不同的自主代理方法,这些方法使我们能够理解文献中实施的一些解决方案。

Toolformer

Toolformer(Schick, 2023)是一项开创性的工作,它采用了这样的想法:一个大型语言模型(LLM)可以访问外部工具来解决任务(如搜索引擎、计算器和日历)而不牺牲其通用性或需要大规模的人类标注。Toolformer 的关键创新在于将工具使用视为一种可推广的技能,而不是局限于特定任务。Toolformer 不是为每个工具或任务设计独立的系统,而是教会模型在统一的语言建模框架内做出关于使用哪个工具、何时使用以及如何使用工具的智能决策。

根据作者的观点,一个大型语言模型(LLM)应该根据两个原则来学习工具的使用:以自监督的方式学习,并保持模型的一般性。Toolformer 旨在以大量自监督的方式进行学习,解决了人工智能发展中的一大瓶颈:人工标注数据的成本和努力。模型不是通过手动标注工具使用的数据,而是被展示了一些工具(API 调用)的工作示例。然后,它在语言建模过程中自动标注了一个大型、未标记的数据集,其中包含工具使用的机遇。这些标注序列被用来微调模型,使其能够自然地学习工具交互。这一点很重要,因为标注数据集是有成本的,但它也教会了 LLM 如何使用工具。一个核心目标是确保 LLM 在执行不同任务时保持其广泛的技能,同时获得使用工具的能力。工具的使用不是为特定提示硬编码的——它成为模型一般技能集的一部分。LLM 学习何时工具可以提高性能,并只在必要时调用它,以保持灵活性并避免过度依赖。简而言之,工具的使用与特定任务无关,而成为一个一般概念。Toolformer 背后的理念是将工具视为对 API 的调用。这种抽象简化了集成,并且可以轻松扩展到不同的工具。例如,当面对数学问题时,模型可能会决定调用计算器 API,或者当需要外部知识时,调用搜索引擎。在给出一系列人类编写的 API 使用示例后,作者使用 LLM 对大量语言建模数据集进行了标注,其中包含潜在的 API 调用。之后,作者对模型进行了微调,以提升模型的能力。采用这种方法,LLM 学习如何控制各种工具,以及何时应该使用它们。

图 9.5 – Toolformer 方法](https://github.com/OpenDocCN/freelearn-dl-zh/raw/master/docs/bd-ai-agt-llm-rag-kg/img/B21257_09_05.jpg)

图 9.5 – Toolformer 方法 (arxiv.org/pdf/2302.04761)

HuggingGPT

HuggingGPT (Shen, 2023) 提出了一个强大的概念:将语言作为一种通用接口,使大型语言模型(LLM)能够与各种模态的外部 AI 模型协作,例如视觉、语音和结构化数据。LLM 不再局限于文本任务,而是获得了管理和协调其他模型以解决复杂、现实世界问题的能力。HuggingGPT 基于两个想法:如果 LLM 无法访问文本之外的信息(如视觉和语音),则其能力有限;在现实世界中,复杂任务可以分解为更易于管理的较小任务。对于特定任务,LLM 在零样本或小样本学习方面表现出色,但通用模型的能力不如特定训练模型。因此,对于作者来说,解决方案是 LLM 必须能够与外部模型协调以利用它们的强大功能。在文章中,他们专注于寻找合适的中间件来连接 LLM 和 AI 模型之间的联系。换句话说,这个想法是 LLM 可以与其他模型进行对话,从而利用它们的特性。其背后的直觉是每个 AI 模型都可以通过总结其功能来用语言描述。换句话说,每个模型都可以从功能上和文本上进行描述。这种描述可以被 LLM 使用。对于作者来说,这代表了新概念的引入:语言作为 LLM 与 AI 模型协作的通用接口。在这个系统中,LLM 充当“大脑”,负责解释用户请求,将其分解为子任务,根据它们的文本描述选择适当的模型,调度和协调模型执行,整合结果,并生成最终响应。

由于与 LLM 的交互是通过提示进行的,因此可以将模型的功能描述输入到 LLM 提示中。然后,LLM 可以被视为管理 AI 模型以进行规划、调度和协作的“大脑”。因此,LLM 不是直接完成任务,而是调用特定模型来解决任务。例如,如果用户问,“图片中有什么动物?”,LLM 会处理这个问题,并推理出它应该使用哪种类型的模型(即图像分类器);模型被调用,返回输出(出现的动物),然后 LLM 生成文本输出以回答“这只动物是 一只鸡。”

到目前为止,主要问题在于收集这些模型功能的文本描述。幸运的是,机器学习(ML)社区为特定任务及其使用的模型(语言、视觉、语音等)提供了高质量的描述。因此,我们需要将 LLM 与社区(GitHub、Hugging Face 等)联系起来。

简而言之,HuggingGPT 是一个由 LLM 驱动的代理,旨在自主解决各种复杂任务。HuggingGPT 将 LLM(原文中是 ChatGPT)与 ML 社区(Hugging Face,但原理可以推广)连接起来;LLM 可以接受不同模态作为输入并完成不同的任务。LLM 充当大脑,将用户的请求分解为子任务,然后将它们分配给专业模型(根据模型描述);然后执行这些模型并整合结果。以下图示强调了这些原则:

图 9.6 – HuggingGPT 总体方案 (https://arxiv.org/pdf/2303.17580)

图 9.6 – HuggingGPT 总体方案(arxiv.org/pdf/2303.17580)

整个 HuggingGPT 过程可以分成四个步骤:

  1. 任务规划:ChatGPT 分析用户请求(理解意图)并将问题转化为可能可解的任务。

  2. 模型选择:ChatGPT 选择 Hugging Face 中存在的适当模型(专家模型)(模型的选择基于提供的描述)。

  3. 任务执行:模型被调用并执行,然后将结果返回给 ChatGPT。

  4. 响应生成:ChatGPT 整合模型的结果并生成答案。

在 Toolformer 中,我们有一个 LLM,模型通过 API 调用调用工具。HuggingGPT 采用类似的方法,但无需微调。在 HuggingGPT 中,一个 LLM 可以被视为一个控制器,将用户请求路由到专家模型。换句话说,LLM 理解任务并规划行动,但这个行动由专家模型(LLM 只是整合结果)执行。这里的 LLM 只是一个促进者,组织不同模型在不同领域解决不同任务的协作。LLM 随后保持其通用性,并可以选择使用哪个工具以及何时使用它(在这种情况下,模型就是工具)。例如,如果一个 LLM 在某个模式下没有能力,它将利用专家模型的能力来完成该任务。LLM 只需要知道调用哪个模型来解决特定任务。因此,HuggingGPT 代表了一个灵活的系统,我们只需要向 LLM 提供文本描述,然后 LLM 就会整合不同的专家模型。

图 9.7 – HuggingGPT 过程 (https://arxiv.org/pdf/2303.17580)

图 9.7 – HuggingGPT 过程(arxiv.org/pdf/2303.17580)

任务规划

在第一步,任务规划,LLM 必须理解任务并将其分解为子任务。在现实世界中,用户请求可能很复杂,其意图复杂,需要任务分解。这是因为单个模型可能无法解决整个任务;相反,可能需要多个模型来处理不同的方面。然后,LLM 需要将任务分解为一系列子任务,并理解这些任务之间的依赖关系以及它们应该执行的顺序。这是通过创建一个特定的提示来完成的。

为了标准化系统,HuggingGPT 的作者使用了一套特定的指令。然后,LLM 必须遵守这些规范以进行任务规划。他们设计了一个标准化的任务模板,并指示 LLM 通过槽位填充进行任务解析。LLM 在槽位填充的指导下填写此模板,从而实现子任务的持续解析和执行。模板必须填充以下四个槽位:

  • 任务 ID:模型为每个任务提供唯一的标识符。此 ID 用于识别任务及其依赖任务,以及所有生成的资源。

  • 任务类型:此槽位包括任务类型;每个任务可以是各种类型(语言、视觉、视频、音频等)。

  • 任务依赖关系:此槽位定义了每个任务的前提条件(模型只有在所有前提条件都完成的情况下才会启动任务)。

  • 任务参数:此槽位包含执行任务所需的所有参数(从文本到图像或其他资源)。这些内容可以来自用户的查询或其他任务的输出。

图 9.8 – HuggingGPT 类型的任务(img/B21257_09_08.jpg)

图 9.8 – HuggingGPT 类型的任务 (arxiv.org/pdf/2303.17580)

作者使用演示来指导模型执行任务(如图像到文本、摘要等)。正如我们在第三章中看到的,添加演示允许模型将任务(少样本提示和情境学习)映射。这些演示告诉模型如何划分任务,顺序如何,以及是否存在依赖关系。此外,为了支持复杂任务,作者包括聊天记录(与用户进行的先前讨论)作为一种工具。这样,模型就可以知道是否已经指示了可以有助于任务的其他资源或请求。

提示提供了 LLM 所需的所有信息。在提示中,我们提供了关于其任务的说明(规划任务分解)、信息检索的位置、如何执行任务的示例以及我们期望的输出。

图 9.9 – HuggingGPT 中提示设计的细节(img/B21257_09_09.jpg)

图 9.9 – HuggingGPT 中提示设计的细节 (arxiv.org/pdf/2303.17580)

模型选择

在规划任务之后,模型开始选择适合任务的适当模型,或模型选择。一旦我们有一个子任务的列表,我们需要选择适当的模型。这是可能的,因为我们有模型及其功能的描述。这项工作的作者已经从机器学习社区(例如,Hugging Face)收集了专家模型的描述。实际上,在 Hugging Face 上,通常是模型的开发者自己用功能、架构、支持的语言和领域、许可等方面的术语来描述模型。

图 9.10 – Hugging Face 上模型描述示例的截图 (https://huggingface.co/docs/transformers/model_doc/bert)

图 9.10 – Hugging Face 上模型描述示例的截图 (huggingface.co/docs/transformers/model_doc/bert)

因此,模型分配被表述为一个单选模型,其中 LLM 必须在给定的特定上下文中从可用的模型中选择最佳模型。然后,考虑到用户的需求和上下文,LLM 可以选择最适合执行任务的专家模型。当然,上下文长度是有限的,你不能输入所有模型描述而不超过这个长度。为了解决这个问题,HuggingGPT 系统应用了一个两阶段过滤和排名过程。首先,根据任务规划期间识别的任务类型(例如,语言、视觉或音频)对模型进行过滤。只有与特定子任务类型相关的模型被保留,显著缩小了模型池。在过滤后的模型中,系统根据下载量对它们进行排序,这作为质量、可靠性和社区信任的代理。假设广泛使用的模型更有可能表现良好。最后,系统选择前 k 个模型描述(其中 k 是一个可配置的超参数)并将它们包含在提示中。然后,LLM 执行单选模型选择,评估上下文和用户需求,从候选列表中选择最合适的模型。这种策略提供了一个平衡的权衡:它保持了提示在可管理的令牌限制内,同时仍然允许 LLM 有足够的选择来做出明智和有效的模型选择。

图 9.11 – HuggingGPT 中用于模型选择的提示设计细节 (https://arxiv.org/pdf/2303.17580)

图 9.11 – HuggingGPT 中用于模型选择的提示设计细节 (arxiv.org/pdf/2303.17580)

模型执行

一旦将特定模型分配给特定任务,就必须执行该模型。请注意,这些模型仅在推理中使用。这些模型通过 Hugging Face API 使用。为了加快执行速度,HuggingGPT 使用混合推理端点。选定的模型将任务参数作为输入,然后将结果发送回语言模型(ChatGPT)。此外,如果没有资源依赖关系,其推理可以并行化。换句话说,相互不依赖的任务可以同时执行。否则,系统会考虑一个模型的输出与另一个模型的输入之间有多少关联(例如,如果一个任务必须有一个子任务的输出才能执行)。为了进行推理,HuggingGPT 使用混合推理端点,主要依赖于 Hugging Face API。当模型通过这些 API 可用且功能正常时,系统会远程执行它们。然而,如果 API 端点不可用或速度慢或遇到网络问题,则使用本地推理作为后备。这种混合设置确保了执行过程中的灵活性和鲁棒性。

作者指出:“尽管 HuggingGPT 能够通过任务规划来开发任务顺序,但在任务执行阶段,仍然可能难以有效管理任务之间的资源依赖关系。”为了解决这个问题,作者简单地使用了一个独特的符号 <resource> 来处理依赖关系。<resource> 是一个特殊标记,代表任务所需的资源(这与任务标识符相匹配),如果所需的任务已完成,则该标记将被资源替换。

图 9.12 – 模型执行( https://arxiv.org/pdf/2303.17580 )

图 9.12 – 模型执行(arxiv.org/pdf/2303.17580)

响应生成

一旦所有任务都执行完毕,就必须生成响应。HuggingGPT 将之前步骤中获得的所有信息(任务规划、模型选择和任务执行)整合成一种简明的摘要(任务、使用的模型和模型的结果)。请注意,模型整合了多个其他模型的结果,特别是通过推理获得的结果,这些结果可能具有不同的格式。这些结果以结构化格式呈现(例如,边界框、概率等),HuggingGPT 将这些结果转换为自然语言以响应用户。因此,HuggingGPT 不仅为任务获取结果,而且以人性化的方式响应用户。

图 9.13 – 响应生成( https://arxiv.org/pdf/2303.17580 )

图 9.13 – 响应生成(arxiv.org/pdf/2303.17580)

定性来看,我们可以看到模型能够解决多个任务。因此,模型能够将任务分解成各种子任务,选择合适的模型,检索结果并有效地整合它们。例如,模型可以进行图像标题、姿态生成,甚至姿态条件图像生成任务。不仅如此,任务可以是多模态的(如文本到视频生成、为视频添加音频等)。其中最有趣的一个方面是,所有这些都是在没有任何额外 LLM 训练的情况下完成的。事实上,所有这些都是在推理过程中完成的(对于 LLMs 和推理中的模型)。优势在于,你可以不进行任何训练就集成额外的模型以处理额外任务;你只需要添加新模型的函数描述。

例如,在这种情况下,我们可以看到多模态任务(文本、视频和音频)的执行。模型被要求执行两个任务:根据描述生成视频和为视频配音。模型并行执行这两个动作。在以下图的底部部分,模型必须依次执行这两个任务:模型首先从图像生成文本,然后生成音频。

图 9.14 – 视频和音频模态多模型合作的定性分析 (https://arxiv.org/pdf/2303.17580)

图 9.14 – 视频和音频模态多模型合作的定性分析 (arxiv.org/pdf/2303.17580)

研究的作者还探索了更复杂的任务,在这些任务中,一个大型语言模型必须组织多个模型的合作才能成功解决问题。HuggingGPT 可以通过任务规划步骤来组织多个模型的合作。结果显示,HuggingGPT 能够在多轮对话场景(用户将请求分成几个轮次)中应对复杂任务。此外,该模型可以通过为每个任务分配一个专家模型来解决复杂任务。例如,“尽可能详细地描述图像”需要模型解决五个任务(图像标题、图像分类、目标检测、分割和视觉问答任务)。这五个任务不是由一个模型解决,而是由五个不同的模型调用和执行。然后,这些模型各自提供必须整合到详细答案中的信息。这些模型在推理过程中并行工作,然后合并最终信息。

图 9.15 – 复杂任务案例研究 (https://arxiv.org/pdf/2303.17580)

图 9.15 – 复杂任务案例研究 (arxiv.org/pdf/2303.17580)

HuggingGPT 的局限性

然而,仍存在一些局限性:

  • 效率:HuggingGPT 需要从 LLM 中进行多次调用;这发生在四个过程中的三个步骤中(任务规划、模型选择和响应生成)。这些交互成本高昂,可能导致响应延迟和用户体验下降。此外,原始文章中使用了闭源模型(GPT-3.5 和 GPT-4),这导致了额外的成本。技术上,可以使用开源模型以相同的方法进行操作。

  • 规划:规划取决于 LLM 的能力。显然,LLM 的能力越强,系统的能力就越好,但 LLM 的推理能力有限,因此规划可能并不总是最优或可行的。您可以选择测试不同的 LLM 或使用经过微调以创建高效计划的 LLM,或者使用经过推理链微调的模型。

  • 上下文长度:模型的上下文长度有一个明确的限制,对于复杂任务来说,这是一个问题。在原始文章中,作者指出,对于某些任务来说,32K 就足够了(特别是如果连接了多个模型)。因此,解决方案可能是使用上下文长度更长的模型。然而,到目前为止,似乎模型并没有有效地使用长上下文。另一个解决方案可能是使用摘要。

  • 不稳定性:这源于 LLM 的随机性质。尽管 LLM 被训练生成文本,并且在这种情况下我们提供了上下文,但模型可以忽略上下文并产生幻觉。文章的作者指出,模型在预测过程中可能无法遵守指令或给出错误答案。这会产生程序流程错误或错误答案。幻觉仍然是 LLM 的一个开放性问题,但有一些策略可以减轻它们。

那么,HuggingGPT 是一个能够通过使用语言作为接口来协调不同专家模型以解决复杂任务的系统。在这里,LLM 仅作为各种 AI 模型的控制器和管理者。它的唯一任务就是协调模型并生成响应。然后模型生成计划,选择模型,并将结果整合到最终响应中。LLM 本身不执行任何任务,而是要求各种专家模型提供解决方案。所有这些都是在推理过程中进行的,而不涉及任何训练。用户提出问题后,系统执行过程,并以自然语言进行响应,从而使交互人性化且流畅。

在以下子节中,我们将探讨各种旨在克服 HuggingGPT 局限性或解决其他专业领域关键挑战的模型。通过这些探索,您将深入了解不同的策略,并学习如何将这些代理应用于现实世界场景。

ChemCrow

我们之前将 HuggingGPT 视为一个协调不同工具(模型)的系统,作为一个通用型模型用于通用任务。在本小节中,我们想要讨论一个应用于专门领域的类似系统。ChemCrow(Bran,2023)遵循与 HuggingGPT 相似的设计理念,但将其应用于专门领域——化学。

通用型大型语言模型(LLM)的局限性在于它们具有通用知识,因此既未针对特定领域进行专门化,也未更新最新信息。这对于许多应用领域(尤其是科学、金融和医疗保健等专门领域)可能是一个问题。此外,LLM 使用一组启发式方法进行计算,而不是通过严格的过程。对于化学等领域的应用,这是一个问题,因此自然想到通过外部工具扩展模型的能力。外部工具提供确切答案,并弥补 LLM 在特定领域的不足。因此,将 LLM 与多个工具集成可以使 LLM 在即使其固有特性构成其适用性限制的领域也能被使用。

一个可以从 LLM 的使用中受益的领域是科学研究。一方面,LLM 已经显示出理解化学的能力,另一方面,有许多针对化学的专门模型,或者至少是针对特定应用的模型。许多这些工具都是由开源社区开发的,并且可以通过 API 访问。尽管如此,整合这些工具并不容易,需要计算编码方面的专业知识,而这通常不是化学研究者的技能之一。受先前工作的启发,本研究(Bran,2023)的作者们提出了他们所谓的 LLM 驱动的化学引擎(ChemCrow),旨在“简化跨药物和材料设计及合成等领域的各种常见化学任务的推理过程。”ChemCrow 与我们所看到的 HuggingGPT 非常相似,其中我们有一个中央 LLM(GPT-4),协调多个工具(在这种情况下,高度专门化于化学)。中央 LLM 被提示特定的指令和信息,以便执行特定任务并以特定格式响应。为了指导 LLM 的推理和工具使用,ChemCrow 采用了一种称为“思考、行动、行动输入和观察”的结构化提示格式,以提示模型对任务(及其当前状态)进行推理,当前状态如何与最终目标相关联,以及如何规划下一步:

  • 思考:模型反思当前问题,考虑其进展,并概述通向最终目标的推理

  • 行动:它选择下一个要使用的适当工具(例如,分子生成器或反应预测器)

  • 行动输入:它指定应发送到所选工具的输入

  • 观察:它记录工具的输出,然后将其纳入下一个推理周期

图 9.16 – ChemCrow 概述(img/B21257_09_16.jpg)

图 9.16 – ChemCrow 概述(arxiv.org/pdf/2304.05376)

因此,在这个系统中,模型通过一个思维步骤(可以将其视为行动规划)并使用工具及其输入(选择和使用模型)来进行。模型获取结果,观察它们,然后再次进行思维步骤,直到达到答案。这个过程与我们之前看到的类似,但更加重视推理和模型的专门化。此外,工具不仅包括模型,还包括搜索互联网或文献的能力;模型还可以运行代码。因此,我们也有系统能力和灵活性的扩展。因此,该研究的作者将这个系统视为一种化学任务的科研助手。

图 9.17 – 人/模型交互导致新分子的发现(img/B21257_09_17.jpg)

图 9.17 – 人/模型交互导致新分子的发现(arxiv.org/pdf/2304.05376)

因此,想法是将 LLM 的推理技能与专业知识以及化学计算工具相结合。结果显示,类似的方法可以导致特定领域的实际应用,例如化学。

SwiftDossier

SwiftDossier 是应用基于代理系统在科学和医疗领域的一个显著例子,特别关注解决这些领域中最关键的挑战之一:幻觉。在医学和制药等领域,幻觉输出——即自信但错误或无法验证的信息——可能导致严重的法律、伦理和安全风险。LLM 拥有巨大的内存,但生成文本是随机的,没有明显验证其来源。这对制药行业或潜在的医疗用途来说是个问题。为了在 SwiftDossier 中解决这个问题,使用了 RAGs 和 LLM 驱动的代理来强制模型生成。该系统不是仅仅依赖 LLM 的内部知识——虽然知识量巨大,但生成是随机的且没有来源验证——而是迫使模型将其响应建立在外部、可靠的数据源上。系统使用不同的工具集来回答不同的问题:科学文章、互联网访问、数据库和其他 ML 模型。使用这一套工具,LLM 可以成功生成报告并最小化幻觉的风险。

图 9.18 – SwiftDossier 架构(img/B21257_09_18.jpg)

图 9.18 – SwiftDossier 架构(arxiv.org/pdf/2409.15817)

ChemAgent

在之前看到的两个例子中,我们有一个添加了工具的代理来弥补通用 LLM 的知识缺陷。换句话说,我们试图通过使用外部信息或工具来执行操作来弥补 LLM 的不足。此外,如果任务本身很复杂,几种方法试图将其分解成更可管理的子任务。代理首先生成一个日程表,然后执行各种子任务,从而结合推理和执行。尽管如此,LLM 仍然可能产生错误,尤其是在化学等复杂领域。

LLMs,虽然作为强大的通用工具,在化学领域面临一些挑战,在这些领域中,任务需要精确推理、准确计算和深厚的领域知识。这些挑战源于 LLMs 生成文本和代码的局限性,并且在科学应用中更为明显,因为小的错误可能导致重大不准确:

  • 在特定领域公式上的挣扎:LLMs 可能会误解或错误地应用专业的化学方程式或符号,尤其是在所需的公式在一般训练数据中不常见的情况下

  • 中间推理步骤错误:在复杂的多步骤任务中(例如,合成规划或性质预测),仅一步的错误可能会级联并导致最终输出错误

  • 代码生成错误:当将文本推理与代码(通常是 Python)结合时,LLMs 经常虚构函数、使用错误的库、产生语法错误或生成无法执行的代码——尤其是对于需要精确库调用和数值稳定性的科学计算

图 9.19 – 化学领域 LLM 失败示例 (https://arxiv.org/pdf/2501.06590)

图 9.19 – 化学领域 LLM 失败示例 (arxiv.org/pdf/2501.06590)

与 LLMs 不同,人类从过去的经验和错误中学习。对于 LLMs 来说,在预训练结束后无法进行学习(微调是一种昂贵的方法,且不能重复使用),因此持续学习仍然是人工智能的一个开放性问题。另一方面,人类可以记住用于类似问题的策略;一旦遇到新问题,他们会学习新的策略,这些策略可以在未来使用。因此,在 ChemAgent 中,作者试图找到一种模拟这一过程的方法。他们提出一个动态库,允许通过持续更新和改进其内容来促进迭代问题解决。该库作为分解化学任务的存储库。换句话说,一个任务被分解成各种子任务,然后解决方案被保存在库中以备将来使用。一旦出现新的任务,库就会更新新的子任务和相应的解决方案,保持库的相关性,并随着时间的推移提高其有用性。受人类认知的启发,该系统有三个不同的记忆组件:计划记忆(高级策略)、执行记忆(特定任务解决方案)和知识记忆(基本的化学原理)。这些记忆组件存储在外部,允许系统在需要时再次找到信息,并且是动态更新的。

图 9.20 – ChemAgent 框架

图 9.20 – ChemAgent 框架(arxiv.org/pdf/2501.06590)

因此,ChemAgent 不仅被动地使用它在记忆中找到的内容,而且允许系统动态地更新记忆。它还使用内存分区来改进问题解决的各个阶段。ChemAgent 将过程分为计划和执行(为每个步骤关联一个特定的记忆)并添加一个作为基本化学原理和公式的参考的记忆。当出现问题时,它被分解成一系列子任务,这些子任务被解决,这些解决方案被保存在记忆中。

法律领域的多代理

另一个可能从代理的使用中受益的领域是法律行业。法律服务对于保护公民权利至关重要,但它们可能特别昂贵,而且律师的数量并不总是足够。此外,公正的判决是一项基本权利,但人类也表现出偏见。在这个领域使用代理可以通过降低成本和允许更公平的访问来彻底改变法律服务。在法律领域,幻觉尤其成问题,如果不是消除,也应尽可能减少。幻觉既源于模型的随机性,也源于训练它们的数据质量。因此,必须从两个轴向上采取行动,以减轻这种现象。

在本小节中,我们希望介绍两种以法律为中心的方法来展示一些已经使用过的有趣元素。再次强调,原则是相同的:一切围绕一个中心元素展开,这个元素是一个 LLM。例如,Chatlaw 关注数据质量以减轻 LLM 幻觉的风险。此外,为了充分利用作者收集到的质量数据集,他们使用了一个知识图谱。此外,他们没有使用单个智能体,而是使用了一个多智能体系统。使用多个智能体使得系统能够模拟与 LLM 交互时不同领域的专业知识,这得益于提示的灵活性。使用多智能体使得在律师事务所内部模拟过程成为可能。作者开发了一个协议,以允许智能体之间有效协作:“四个独立的智能体角色,分别负责初步信息收集、深入材料研究、法律咨询和最终咨询报告撰写。”这样,过程就更加彻底。再次强调,他们为整个系统只使用了一个 LLM(作者使用了 GPT-4)。

图 9.21 – Chatlaw,多智能体协作(img/B21257_09_21.jpg)

图 9.21 – Chatlaw,多智能体协作(arxiv.org/pdf/2306.16092v2)

另一种有趣的方法是作者(Hamilton,2023;arxiv.org/pdf/2301.05327)使用 LLM 模拟法院的判决。在这里,同样使用了一个多智能体系统,其中每个智能体代表一位法官。每位法官提出一个意见,然后得出多数意见。因此,当案件被发送给九位法官时,系统收到九个意见,然后产生一个单一的意见。这种方法依赖于并行进行九次评估以及这些评估的一致性(多数票获胜)。

图 9.22 – 多法官系统(img/B21257_09_22.jpg)

图 9.22 – 多法官系统(arxiv.org/pdf/2301.05327)

这项工作展示了如何利用 LLM 创建多个智能体,它们可以协同工作以减轻幻觉。作者进一步证明了使用 LLM 作为系统中心可以实现的灵活性。这项研究的局限性在于使用了同质化的法官(最好是构建由不同模型组成的集成,以避免不同法官具有相同的偏见),这可能导致重复的意见。

多智能体在医疗应用中的使用

跨学科研究是复杂的,通常需要由不同领域专家组成的研究团队。通常,科学研究是由每个研究人员处理特定方面并掌握不同技术的团队进行的。例如,AlphaFold 2 是 34 位不同专业知识(计算机科学、生物信息学和结构生物学)的研究人员的成果。显然,招募大量专家团队需要时间(而且并不总是容易找到具有正确专业知识的人),而且成本高昂。只有少数机构和公司能够承担最雄心勃勃的项目。然而,最近创建的 LLM 在科学主题上的知识越来越广泛,我们之前已经看到这种知识可以与工具的使用联系起来。ChemCrow 是解决化学问题的例子,但它无法处理开放式的跨学科研究问题。最近,人们已经通过创建可以处理端到端过程的管道来解决这一问题。例如,一位 AI 科学家(Lu,2024)进行了一个从构思想法开始,以在机器学习上撰写科学论文结束的过程。AI 科学家被赋予了一个广泛的研究方向,产生了一个想法,进行文献搜索,规划并执行实验,撰写手稿,最后校对。所有这些工作都是由一个类似于 LLM 的代理完成的,该代理连接到工具并按顺序进行。

图 9.23 – AI 科学家过程的说明(img/B21257_09_23.jpg)

图 9.23 – AI 科学家过程的说明(arxiv.org/pdf/2408.06292)

其他研究也展示了类似的过程,但它们仍然局限于特定的领域和线性过程。对于科学研究,我们希望找到结合不同专业知识的方法。因此,Swanson (2024) 提出了一种旨在对复杂问题进行跨学科科学研究的虚拟实验室,用于人机协作。在虚拟实验室中,人类引导一组跨学科代理来管理复杂过程。不同的代理拥有不同的专业知识,并由一个 LLM 运行。每个代理都与其他代理和人类进行交互。通过这种方式,研究的作者构建了一个灵活的架构。在这里,人类为代理提供指导,而代理则决定搜索方向和设计解决问题的方案。每个代理都由一个提供给 LLM(文章中为 GPT-4)的提示(包含关于角色、专业知识、目标和可用工具的信息)控制。然后,虚拟实验室通过小组或个人会议进行研究。

人类提供问题和议程以启动讨论。在团队会议中,代理讨论研究问题并共同努力实现全局目标。在个人会议中,单个代理必须解决一个任务(例如编写代码),代理可以单独工作或与另一个提供关键反馈的代理一起工作。通过一系列全局和个人会议,团队解决研究问题。

图 9.24 – 虚拟实验室架构 (https://www.biorxiv.org/content/10.1101/2024.11.11.623004v1.full)

图 9.24 – 虚拟实验室架构 (www.biorxiv.org/content/10.1101/2024.11.11.623004v1.full)

在虚拟实验室中,有一个主要研究员(PI),其目的是最大化研究的影响力,并自动为项目创建一组适当的科学家代理(生物学家或计算机科学家)(基于 PI 提供的项目描述)。PI 在提示中定义每个代理的角色、专业知识和目标。此外,还可能有一个专门用于项目批评的代理。之后,会议开始。每次会议都遵循一组组织成结构的输入:议程(讨论内容的描述)、议程问题(会议中要回答的问题集)、议程规则(使会议更顺畅的可选规则)、摘要(前次会议的可选摘要)、背景(有助于会议的额外信息)和回合(讨论回合的数量,以防止讨论无休止地进行)。在团队会议中,所有代理都参与讨论,人类编写议程(可选地,包括规则和问题),然后进行不同回合的讨论。PI 开始,然后每位科学家代理(加上批评代理)对讨论发表意见。最后,PI 总结代理提出的问题点,对代理的输入做出决定,并提出后续问题。经过各种回合后,PI 编写一个人类可以阅读的最终摘要。

在个人会议中,人类提供议程并选择代理,代理执行任务(此外,还可能有批评代理,提供批评)。在代理和批评者之间经过一系列回合后,代理提供回应。此外,还可以进行并行会议,其中多个代理执行相同任务,并在与 PI 的最终会议中得出最终答案。

图 9.25 – 虚拟实验室并行会议 (https://www.biorxiv.org/content/10.1101/2024.11.11.623004v1.full)

图 9.25 – 虚拟实验室并行会议 (www.biorxiv.org/content/10.1101/2024.11.11.623004v1.full)

以这种方式,作者创建了一个灵活的框架,结合了在单人和协作环境中工作的异构代理。需要注意的是,在这种方法中,有一个人类参与其中;也就是说,人类是系统的中心,并积极与 AI 合作。这个过程模仿(尽管当然是以简化的方式)了人类团队在解决复杂问题时的工作和决策过程。为了测试这项工作的实用性,作者测试了虚拟实验室在设计和结合 SARS-CoV-2 KP.3 变异株刺突蛋白的抗体或纳米抗体方面的能力。这是一个复杂的问题,因为 SARS-CoV-2 进化迅速,因此必须找到一个快速的系统来设计可以阻止它的抗体。虚拟实验室首先创建了一个能够应对这个问题的团队(PI 为这个问题组建了合适的研究人员团队)。在团队会议上,项目方向被描述,并讨论了主要细节。然后,举行了一次关于可以使用哪些工具以及如何选择的团队会议,以及一系列个人会议,研究人员使用各种工具创建抗体设计工作流程。在与 PI 的会议中,定义了工作流程。

图 9.26 – 抗体设计虚拟实验室 (https://www.biorxiv.org/content/10.1101/2024.11.11.623004v1.full)

图 9.26 – 抗体设计虚拟实验室 (www.biorxiv.org/content/10.1101/2024.11.11.623004v1.full)

虚拟实验室成功地设计出了抗体,随后通过实验进行了验证。该系统成功地创建了一个复杂的流程,使用序列模型来设计抗体(从而解决了一个真实且复杂的问题)。构建这样的系统通常需要一个跨学科团队,因为需要用不同的专业知识来解决问题。因此,拥有不同专业知识的代理可以从前不同的角度讨论问题,从而为科学研究的基本要素(批判性)增添了内容。这是通过一系列会议来完成的,其中 AI 是人类合作伙伴。我们看到的是,通过多轮会议(小组和个人)的创建,形成了一个既灵活又复杂的系统。

在这个阶段仍然存在一些限制。例如,模型的知识截止到某个点,因此它们可能不知道最新发布的工具,因此可能会建议旧模型(或实现中存在问题的模型)。解决这个问题的一个方法可能是使用 RAG 或互联网搜索。另一个限制是,该系统并不完全自包含;它附带了一个议程和一组经过精心设计的提示。在这个系统中,人类仍然参与其中,必须提供指导。没有指导,AI 模型可能会给出模糊的答案,或者除非特别要求,否则不会做出决定。有时它们无法完成任务,或者偏离了它们应该做的事情。无论如何,这个系统是灵活的,可以无差别地应用于许多其他问题。

将不同领域的专业知识与人类反馈相结合似乎是取得更好成果的关键。在这方面,代理实验室被设计用来生成整个研究工作流程(从文献综述和实验到报告撰写),这一切都基于人类提供的初始研究想法。在这个系统中,过程从收集和分析相关论文开始,接着是协作规划和数据准备,一系列实验,以及报告生成。这个过程可以分为三个阶段:

  • 文献综述阶段:在这个阶段,为给定的研究想法收集文章。博士代理利用 arXiv API 检索相关论文,综合它们,并提供见解。这个代理使用搜索 API、摘要模型和文献管理系统作为工具。这个过程会迭代,直到达到一定数量的相关文章。

  • 实验阶段:第一步是制定计划,根据文献综述和研究目标生成一个计划。在这个阶段,博士和博士后代理进行协作和讨论如何实现目标,生成一个定义了要实施哪些机器学习模型、使用哪些数据集以及其他必要实验步骤的计划。一旦计划确定,数据准备阶段就开始了,在这个阶段,根据定义的计划生成数据准备代码。机器学习工程师代理可以访问 Hugging Face 数据集,然后代码被编译并提交。在运行实验阶段,机器学习工程师代理执行实验计划。在这个阶段,代码被生成、测试和改进。然后对结果进行解释。在这个阶段结束时,博士和博士后代理讨论结果。如果他们同意发现的有效性,他们将提交结果,这些结果将成为报告的基础。

  • 报告撰写:在报告撰写阶段,博士和教授代理将研究结果综合成一份全面的学术报告。从初始框架(摘要、引言、背景、相关工作、方法、实验设置、结果和讨论)开始,他们开始生成文本(使用 LaTeX 编写,以便于修订和校正)。在撰写过程中,系统访问文献,并迭代地纠正文章以确保准确性、清晰度和与研究目标的契合度。最后,进行一种论文审查以确保文章的正确性。请注意,在此过程中,系统会收到来自人类的反馈。

该系统的关键特性是代理能够自主执行重复性任务(例如,文献检索和编码),但在需要创造力和判断力的情况下允许人类输入。代理之间通过沟通中间结果来确保各方之间的协同。在每一个阶段,通过反思和反馈进行迭代改进。

图 9.27 – 代理实验室工作流程 (https://arxiv.org/pdf/2501.04227)

图 9.27 – 代理实验室工作流程 (arxiv.org/pdf/2501.04227)

代理实验室旨在快速探索想法并帮助研究人员能够同时探索多个研究方向。代理实验室的结构允许它从由人类研究人员提出的一个想法开始,执行整个工作流程。在这项工作中,他们不仅关注结果的准确性,还试图找到一种更有效率的任务解决方法(先前的工作需要过多的计算成本)。

图 9.28 – 代理实验室方案 (https://arxiv.org/pdf/2501.04227)

图 9.28 – 代理实验室方案 (arxiv.org/pdf/2501.04227)

作者指出,在各个阶段融入人类反馈显著提高了研究成果的质量。此外,他们还表示,由代理实验室生成的机器学习代码达到了现有最先进方法的性能,并且为人类阅读的报告质量显著良好。

这些系统表明,通过结合人类反馈,可以解决复杂任务。然而,这些系统依赖于人类反馈,因为截至目前,大型语言模型(LLMs)尚不具备真正的推理能力。这有几个局限性:系统可能在设计超出标准方法的创新实验方面遇到困难,尤其是在需要创造性问题解决或新颖方法的应用领域。系统仍然会在代码中产生错误(错误或低效),它继续维持高计算成本(多个 LLM 调用),智能体之间的通信尚未完美,与专家相比,报告生成仍然不够优化,它对高度专业化的或利基研究领域的泛化能力较差(它们在训练数据和文献中表现不佳),并且存在几个尚未解决的伦理问题。

在本节中,我们探讨了具有单个智能体或多个智能体的不同系统。在下一节中,我们将看到 HuggingGPT 的实际工作方式以及我们如何创建多智能体系统。

与 HuggingGPT 一起工作

您可以使用两种方式使用 HuggingGPT:

  • 在本地克隆仓库

  • 使用网络服务

在这里,我们将探讨两种方法。主要区别在于,当我们本地克隆仓库时,我们会下载所有模型,系统执行将在本地进行。相比之下,网络服务方法要求执行在服务中进行。在两种情况下,所有模型都用于推理;区别在于模型的执行位置和使用的资源。此外,两种方法都支持使用基于网络的图形用户界面。

在本地使用 HuggingGPT

要克隆 HuggingGPT(相应的仓库称为 Jarvis),使用 Git LFS 非常有用。Git LFS 是 Git 的开源扩展。Git 旨在管理代码仓库,但不处理大型二进制文件(如视频、数据集或高分辨率图像)。Git LFS 对于包含大型资产(例如,数据集、视频或二进制文件)的仓库至关重要,因为否则 Git 在处理大文件时效率低下。Git LFS 通过在常规仓库对象之外存储大文件并替换 Git 仓库中的轻量级引用(指针)来解决此问题。Git LFS 通过在仓库的常规对象之外存储大文件,使使用大型对象时标准化更好,并在与 GitHub 仓库(如克隆、推送和拉取)操作时提高性能。指针包含有关文件的各种元数据(例如,大小、哈希和位置),当我们克隆一个仓库时,Git LFS 通过利用这些指针中的信息下载文件。这使我们能够将代码操作与对大文件的操作分开。一般来说,对于涉及机器学习、游戏开发或视频编辑的项目,通常使用 Git LFS,因为它可以简化并加快下载过程。在机器学习项目中,模型权重非常大且经常更新;使用 Git LFS 允许我们高效地跟踪和管理这些文件——例如下载的模型——而不会使主仓库膨胀。正如我们提到的,HuggingGPT 使用几个大型模型(例如,有不同类型的扩散模型,可能占用几个 GB),Git LFS 允许更容易地管理。

要安装 Git LFS,您可以访问官方网站 (git-lfs.github.com/) 并下载适用于您操作系统的安装程序(Windows、macOS 或 Linux)。运行下载的安装程序。在 macOS 上,双击.pkg文件或使用 Homebrew 包管理器:

brew install git-lfs

运行以下命令以启用 Git LFS 对您的用户:

git lfs install

一旦您将 Git LFS 作为 Git 扩展安装到您的计算机上,它将自动识别和跟踪仓库中是否存在大文件,并对其进行管理。它修改或创建一些 Git 配置条目(例如在~/.gitconfig中),以便您创建的未来克隆和仓库可以无额外麻烦地使用 LFS。

克隆启用了 LFS 的仓库就像它是一个常规仓库一样简单(Git LFS 会在后台处理文件,并自动管理大文件):

git clone https://github.com/example/repo.git

如果我们想,我们可以轻松地进行大文件跟踪:

git lfs track "*.bin"
git add .gitattributes
git commit -m "Track large .bin files with LFS"

Git LFS 与经典 Git 命令兼容。拉取/推送操作与正常 Git 工作流程中的操作一样——除非仓库需要特定的凭据或令牌,否则不需要特殊步骤。

到目前为止,我们可以继续安装 HuggingGPT。HuggingGPT 仓库存储在github.com/microsoft/JARVIS。

图 9.29 – Microsoft HuggingGPT

图 9.29 – Microsoft HuggingGPT

第一步是克隆仓库:

git clone https://github.com/example/microsoft/JARVIS.git

图 9.30 – Microsoft HuggingGPT 克隆

图 9.30 – Microsoft HuggingGPT 克隆

git clone命令从远程 URL 启动仓库的下载。终端输出指示正在下载的仓库:对象(元数据和更改)和差异压缩(一个通过仅发送版本之间的差异来最小化传输数据量的过程)。注意以下内容:

  • 接收对象:100% (150/150),完成。:这确认了所有对象(文件和历史记录)都已接收

  • 解析差异:100% (85/85),完成。:Git 通过应用接收到的更改(差异)来重建实际的仓库状态

一旦我们克隆了仓库,我们就可以转到本地仓库(本地文件夹):

cd JARVIS/hugginggpt/server

这一步是为创建或管理conda环境做准备,确保操作在相关项目目录的上下文中执行。

然后,我们创建一个新的名为jarvis的conda环境(或我们可以选择其他名称),并指定它应使用 Python 版本 3.8:

conda create -n jarvis python=3.8

注意,-n表示我们想要为我们的项目创建一个新的环境,而python=3.8表示我们明确指定此环境的 Python 版本为 3.8:

conda环境允许我们隔离依赖关系,避免与全局 Python 安装或其他项目发生冲突。

注意conda正在处理以下过程:

  • conda从其仓库中检索有关所需包和依赖项的信息。这确保了 Python 3.8 与任何其他要安装的库之间的兼容性。

  • conda解决潜在的依赖冲突,并最终确定要安装的包列表。

由于你可能之前已经安装了conda,我们只需要更新它:

conda update -n base -c defaults conda

图 9.31 – 更新 conda

图 9.31 – 更新 conda

在解决环境并准备创建它之后,conda安装新环境所需的基本包。每个包都列在仓库(pkgs/main)及其特定版本(在这种情况下,我们使用 macOS)旁边。

终端提示我们继续([y]/n)?。请记住,用y响应以确认安装这些包。

注意以下元素:

  • conda确保必要的依赖关系准备就绪,且无冲突

  • 验证交易:它检查包元数据的完整性,并确保所有包之间的兼容性

  • conda将包安装到指定的环境中

一旦完成这些步骤,新的环境(jarvis)就准备好使用了。

成功创建后,conda为用户提供管理新环境的命令。

要激活此环境,请使用以下命令:

conda activate jarvis

要停用活动环境,请使用以下命令:

conda deactivate

记住,激活操作会将用户的终端会话切换到使用jarvis环境,隔离其依赖和 Python 版本。注意,提示符从(base)变为(jarvis),表示终端现在正在jarvis环境中运行。该环境的隔离 Python 版本(3.8)及其依赖现在正在使用。从此点开始安装的任何库或工具都将局限于该环境,避免与其他项目发生干扰。

图 9.32 – conda 激活

图 9.32 – conda 激活

在这一点上,我们开始安装各种需求:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

以下命令使用pip安装requirements.txt文件中列出的依赖项(通常,在需求文件中提供了一个包列表)。这些需求是安装 HuggingGPT 所必需的:

pip install -r requirements.txt

HuggingGPT 中的以下注释强调必须安装 Git LFS。此脚本(作为项目的一部分提供)自动化下载本地或混合推理模式所需的模型文件。提醒一下,本地意味着模型完全在本地机器上运行,混合意味着推理涉及本地和远程执行的混合,正如 HuggingGPT 论文(arxiv.org/abs/2303.17580)和前述章节所述:

# download models. Make sure that `git-lfs` is installed.
bash download.sh # required when `inference_mode` is `local` or `hybrid`

一旦安装完毕,我们就可以开始执行:

python model_server.py --config config/config.default.yaml # required when `inference_mode` is `local` or `hybrid`.
python awesome_chat.py --config config/config.default.yaml --mode server # for text-davinci-003

仓库中有不同的脚本:

  • model_server.py:此脚本运行一个模型服务器,根据配置文件(config/config.default.yaml)处理机器学习模型。配置文件指定了参数,例如推理模式(本地或混合)、模型路径和硬件要求。

  • awesome_chat.py:此脚本启动一个用于文本生成或聊天机器人功能的服务器。

图 9.33 – Microsoft HuggingGPT 完成安装

图 9.33 – Microsoft HuggingGPT 完成安装

由于我们已经初始化了awesome_chat.py,我们可以使用一个用户友好的网页。

在网上使用 HuggingGPT

如果您不想安装 HuggingGPT,可以使用在线套件(在 Hugging Face Gradio 上:huggingface.co/gradio)。Hugging Face Gradio是一个 Python 库,简化了创建用户友好的基于 Web 的界面以供机器学习模型和其他 Python 应用程序使用的流程。

使用 Gradio,开发者可以快速构建交互式演示,例如文本生成、图像分类和音频处理等任务。这些界面允许用户通过提供输入(例如文本、图像或音频)并在浏览器中查看实时输出,直接在浏览器中测试模型。Gradio 高度可定制,支持与流行的 ML 框架(如 PyTorch、TensorFlow 和 Hugging Face 模型)集成,并可通过公共链接或嵌入到 Web 应用程序中轻松共享演示。

作者创建了一个 Gradio 界面(从本地启动 Jarvis 允许此类界面)。Gradio 空间可以通过以下链接访问:huggingface.co/spaces/microsoft/HuggingGPT。

正如之前在系统及其安装描述中所述,HuggingGPT 是一个将 LLM 与 ML 社区连接起来的系统。在 Web 界面上,它也执行了完全相同的功能:将一个 LLM 与托管在 Hugging Face 上的 ML 模型集连接起来。由于硬件限制,Web 界面仅在local/inference端点部署了少量模型(此界面作为了解和查看系统工作原理的示例)。

注意,我们需要两个令牌,用户需要从每个网站获取:

  • Hugging Face 令牌:这是一个个人认证密钥,允许用户安全地访问 Hugging Face 的服务,包括其 API、模型、数据集以及平台托管的其他资源。此令牌作为您账户的标识符,确保您的请求得到 Hugging Face 系统的授权并与您的账户关联。该令牌随后用于验证和使用推理中的模型。Hugging Face 对某些服务实施速率限制,尤其是对 Web 推理。

  • OpenAI 密钥:这是 OpenAI 提供的唯一认证密钥,允许开发者安全地访问和交互 OpenAI 的 API 和服务,例如 GPT(例如 GPT-3.5 或 GPT-4)、DALL·E、Codex 和 Whisper。此密钥作为个性化凭证,用于识别您的账户并授权您使用 OpenAI 的平台。该密钥是向 OpenAI API 端点发送请求进行验证所必需的。OpenAI 使用您的 API 密钥跟踪您的使用情况(例如,API 调用次数和处理的令牌数)并相应地向您收费。在这种情况下,使用的是 GPT-4 的连接。

一旦我们准备好了令牌,我们就可以输入我们的问题并点击提交。

图 9.34 – HuggingGPT 界面

图 9.34 – HuggingGPT 界面

我们可以看到有两个主要面板:

  • 左侧面板:提供了一个标记为聊天机器人的文本输入框。该字段用于用户输入,例如问题或命令,以与 HuggingGPT 系统交互。

  • 右侧面板:在聊天机器人旁边预留了一个空白的框,用于显示 HuggingGPT 生成的响应或输出。

在聊天框下方,有一个标有发送的按钮,允许用户将他们的查询提交给 HuggingGPT。

注意,系统已经提供了我们可以使用的现成示例:

图 9.35 – HuggingGPT 提供的示例

图 9.35 – HuggingGPT 提供的示例

我们输入 OpenAI 和 Hugging Face 的标记。使用标有聊天机器人的文本输入框,我们可以向 HuggingGPT 发送自然语言查询(“你能告诉我你在图片中看到哪种披萨吗?”)并通过发送按钮发送查询。此外,还可以添加图像或其他多媒体元素(在我们的案例中,我们添加了一张披萨的图片):

图 9.36 – HuggingGPT 交互示例

图 9.36 – HuggingGPT 交互示例

在图右侧的面板上,我们看到系统正在处理的过程:1 个放在木桌上的意大利辣香肠披萨. 这表明系统成功处理了输入图像,并识别出描绘为意大利辣香肠披萨的对象。这是一个典型的目标检测任务,系统正在使用一个模型来识别对象(这并不是一个进行图像识别的 LLM,而是一个由 LLM 调用的专门模型)。

聊天机器人根据推理结果提供详细的答案:

Sure, based on the inference results, the pizza in the picture is a pepperoni pizza.

HuggingGPT 解释了过程:

  1. 第一步涉及使用图像到文本模型来获取图像的描述。ViT-GPT2-COCO-EN 是一个视觉语言模型,它结合了一个用于图像编码的视觉 Transformer(ViT)和一个用于自然语言生成的GPT-2,在COCO 数据集上进行了图像标题任务的微调。该模型为输入图像生成英文描述性标题,有效地将视觉内容转换为连贯的文本描述。它利用 ViT 提取详细图像特征,并利用 GPT-2 的语言生成能力来生成准确且上下文丰富的标题。

  2. 然后,HuggingGPT 使用一个目标检测模型来识别图像中的对象。这个目标检测模型也提供了类似的响应,因为它识别了披萨和餐桌。DETR-ResNet-101 是一个用于目标检测和图像分割的视觉模型。它结合了一个用于特征提取的ResNet-101 主干(卷积神经网络)和一个用于检测和定位图像中对象的基于 transformer 的架构。DEtection TRansformer(DETR)使用 transformer 来建模图像中的全局关系,从而在不需要传统区域提议网络的情况下实现更准确的目标检测。

  3. 然后,一个视觉回答模型确认图像中是哪种披萨。ViLT-B/32-Finetuned-VQA 是一个针对视觉问答(VQA)任务进行微调的视觉和语言转换器模型。它结合了一个轻量级的视觉和语言转换器(ViLT)架构、基于补丁的图像分词器和转换器层,以联合处理视觉和文本输入。B/32 指的是使用 32 x 32 像素的补丁大小进行图像编码。该模型专门针对 VQA 数据集进行微调,旨在通过推理视觉和文本信息来回答关于输入图像的自然语言问题。

  4. 最后,LLM 观察到三个模型意见一致,因此对响应有信心。

回顾一下,HuggingGPT 接收用户的请求并选择模式。这些模式被执行,输出被收集。系统分析这些输出是什么,并生成最终响应。

图 9.37 – HuggingGPT 响应示例

图 9.37 – HuggingGPT 响应示例

HuggingGPT 通过一个简单的例子展示了如何使用 LLM 解决多模态任务。这一切都是使用提示中的信息和一系列工具完成的。

在本节中,我们看到了一个单个 LLM(单个代理)处理任务,将其分解为子任务,并执行不同的模型。一个更优雅的方法是使用多个代理从不同的角度处理任务,协作并交互以解决问题。在下一个小节中,我们将看到如何实现这一点。

多代理系统

在本节中,我们看到了如何创建一个考虑不同代理和一系列工具(如 ML 模型)的系统。整个代码可以在Multi_Model–Travel_Planning_System.py脚本中找到。

作为一般概述,该系统实现了一个使用多个代理创建个性化旅行计划的旅行规划助手。然后,系统结合天气预测、酒店推荐、行程规划和电子邮件摘要。换句话说,我们有四个不同的代理,每个代理处理旅行规划的不同方面:

  • WeatherAnalysisAgent:使用随机森林回归器根据历史天气数据预测最佳访问地点的时间。在过去的天气数据(月份、纬度、经度和天气评分)上训练,并根据天气评分预测最佳的旅行月份。然后,该代理使用一个 ML 模型进行预测(一个专门为系统训练的模型)。

  • HotelRecommenderAgent:使用句子转换器嵌入根据用户偏好查找酒店。存储酒店描述并将它们转换为嵌入,然后使用语义相似性将用户偏好与最相关的酒店匹配。基于用户偏好,该代理在其库中搜索可能的解决方案。

  • ItineraryPlannerAgent:使用 GPT-2(文本生成管道)创建个性化的旅行行程。代理根据目的地、天气预测和酒店推荐生成行程计划。

  • SummaryAgent:使用 GPT-2 为客户生成摘要电子邮件。此摘要包括酒店费用(每晚费用×持续时间)和额外的每日费用。之后,它生成包含旅行详情、费用细分和行程高光的个性化电子邮件。

下图展示了代理和流程的架构:

图 9.38 – AI 旅行规划系统工作流程的活动图,显示了从数据加载和代理初始化到行程规划和结果输出的完整序列

图 9.38 – AI 旅行规划系统工作流程的活动图,显示了从数据加载和代理初始化到行程规划和结果输出的完整序列

TravelPlanningSystem将所有代理连接在一起,基本上是系统的主控制器。因此,系统模仿了以下流程:

  1. 用户提供目的地、偏好和持续时间。

  2. 天气代理预测最佳访问时间。

  3. 酒店代理找到匹配的住宿。

  4. 行程代理创建每日计划。

  5. 摘要代理生成电子邮件并计算费用。

详细来说,我们可以看到这里的代理被定义为类。WeatherAnalysisAgent是一个基于机器学习的组件,它分析历史天气数据并预测给定位置的最好访问月份。它使用随机森林回归器来完成这项工作。我们可以将其视为一个使用机器学习模型执行任务的代理。此片段正在初始化代理:

class WeatherAnalysisAgent:
def __init__(self):
           self.model = RandomForestRegressor(n_estimators=100)

此代理创建一个RandomForestRegressor模型(n_estimators=100表示模型由 100 个决策树组成),必须从历史天气数据中学习模式,然后必须预测不同月份和位置的天气分数:

def train(self, historical_data: Dict):
        X = np.array([[d['month'], d['latitude'], d['longitude']] for d in historical_data])
        y = np.array([d['weather_score'] for d in historical_data])
        self.model.fit(X, y)

如前所述,此模型不是预先训练的(即,它不用于推理)而是在现场训练的。为此,我们类中有一个train方法。随机森林使用月份、纬度和经度来学习预测一个weather_score值(表示该月天气好坏的数值分数)。在这个片段中,数据被处理,模型被训练。

在这一点上,我们可以使用predict_best_time作为方法,根据训练的天气模型预测最佳访问月份。在这种情况下,该方法只接受两个输入(位置的纬度和经度)并返回其预测:

def predict_best_time(self, location: Dict) -> Dict:
        # Predicts the best time to visit a location based on weather patterns
        predictions = []
        for month in range(1, 13):
            # predict returns a 2D array, we take the first (and only) element
            prediction = self.model.predict([[
                month,
                location['latitude'],
                location['longitude']
            ]]).item()  # .item() converts numpy array to scalar
            predictions.append({'month': month, 'score': float(prediction)})
        return {
            'best_months': sorted(predictions, key=lambda x: x['score'], reverse=True)[:3],
            'location': location
        }

注意,我们初始化预测,它将包含 12 个月的所有分数(实际上,预测是通过循环所有 12 个月进行的,从一月到十二月)。最后,我们将列表从最好到最坏排序,以确定最佳访问月份。然后,该方法返回具有最高预测天气分数的前三个月份的列表。

HotelRecommenderAgent是一个酒店推荐系统,它利用语义相似性将酒店与用户偏好相匹配,并使用自然语言处理(NLP)来理解和比较酒店描述和用户偏好:

class HotelRecommenderAgent:
    def __init__(self):
        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
        self.hotels_db = []
        self.hotels_embeddings = None

在代理初始化期间,加载了all-MiniLM-L6-v2(一个为语义相似性设计的预训练 NLP 模型)。这个模型是一个嵌入器(如第五章中所述),将文本(酒店描述和用户偏好)转换为向量嵌入(多维空间中的数值表示)。一旦我们有了向量,我们就可以测量两个向量之间的相似度(用户偏好和酒店描述)。代理检索可用的酒店(self.hotels_db)并可以存储所有酒店描述的预计算嵌入(数值向量)。

接下来,在下面的代码片段中,我们有一个add_hotels函数,它将酒店添加到数据库中,并计算描述的嵌入,然后将它添加到我们的嵌入数据库中。find_hotels函数通过语义相似性找到符合用户偏好的酒店:

def add_hotels(self, hotels: List[Dict]):
        self.hotels_db = hotels
        descriptions = [h['description'] for h in hotels]
        self.hotels_embeddings = self.encoder.encode(descriptions)
    def find_hotels(self, preferences: str, top_k: int = 5) -> List[Dict]:
        pref_embedding = self.encoder.encode([preferences])
        similarities = np.dot(self.hotels_embeddings, pref_embedding.T).flatten()
        top_indices = similarities.argsort()[-top_k:][::-1]
        return [
            {**self.hotels_db[i], 'similarity_score': float(similarities[i])}
            for i in top_indices
        ]

发生的情况是我们对用户的偏好进行嵌入,然后计算与所有存储的酒店向量的余弦相似度。在这种情况下,我们选择与我们的酒店描述最接近的五个酒店(top_k=5表示选择前五个酒店)。

ItineraryPlannerAgent负责根据目的地信息(城市或景点)、天气预测(最佳访问月份)、酒店推荐(选择的住宿)和旅行时长(天数)自动生成旅行行程。它使用自然语言模型(GPT-2)根据这些输入生成定制的旅行行程:

class ItineraryPlannerAgent:
    def __init__(self):
        # Uses a language model for generating itineraries
        self.planner = pipeline(
            "text-generation",
            model="gpt2",  # In production, use a more powerful model
            max_length=500,
            truncation=True,
            pad_token_id=50256
        )

代理使用 Hugging Face transformers 库初始化一个 NLP 模型(GPT-2 模型,这是一个用于文本生成的预训练语言模型)。我们选择一个专注于文本生成的管道("text-generation"表示模型将根据提示生成文本)。其他参数意味着我们将生成的文本限制在 500 个标记以内(max_length=500)并确保截断。

由于我们通过提示与 LLMs 交互,我们有一个方法允许我们创建一个结构化的提示,然后我们将使用这个提示与模型交互。这个提示被设计成能够生成一个旅行计划,其中它输入一些特定的信息:停留时长(持续时间)、目的地、天气信息(我们之前确定的最佳月份)、酒店选择(由之前的代理识别),以及一个景点列表:

def _create_prompt(self, destination_info: Dict, weather_info: Dict,
                   hotel_info: Dict, duration: int) -> str:
    return f"""Create a {duration}-day itinerary for {destination_info['name']}.
Weather: {weather_info['best_months'][0]['month']} is the best month.
Hotel: Staying at {hotel_info[0]['name']}.
Attractions: {', '.join(destination_info['attractions'])}."""

在这一点上,我们可以创建行程;create_itinerary 方法精确地接受包含我们所需所有信息的先前提示(目的地、天气、酒店选择和旅行时长)。在 create_itinerary 方法内部有一个名为 _create_prompt 的方法来生成提示。GPT-2 模型接受输入提示并生成详细的行程:

def create_itinerary(self, destination_info: Dict, weather_info: Dict,
                     hotel_info: Dict, duration: int) -> Dict:
    prompt = self._create_prompt(destination_info, weather_info, hotel_info, duration)
    #Generate the itinerary
    response = self.planner(prompt)[0]['generated_text']
    return {
        'itinerary': response,
        'duration': duration,
        'destination': destination_info['name']
    }

最后一个代理,即 SummaryAgent,负责总结旅行详情,计算总估算成本,并使用 GPT-2 为客户生成个性化电子邮件。我们的代理初始化与之前的代理类似;唯一的区别在于,在这种情况下,生成长度更大(max_length=1000):

class SummaryAgent:
    def __init__(self):
        # In production, use a more powerful LLM like GPT-4 or Claude
        self.llm = pipeline(
            "text-generation",
            model="gpt2",
            max_length=1000,
            truncation=True,
            pad_token_id=50256
        )

calculate_total_price 是代理用来计算旅行总成本的工具(记住,LLMs 在算术方面并不擅长,因此最好使用外部工具):

def calculate_total_price(self, hotel_info: Dict, duration: int) -> float:
        # Calculate total trip price
        hotel_cost = hotel_info[0]['price'] * duration
        # Estimate additional costs (activities, meals, transport)
        daily_expenses = 100  # Simplified example
        additional_costs = daily_expenses * duration
        return hotel_cost + additional_costs

代理执行一系列非常简单的计算:

  • 每晚的酒店价格乘以停留时间

  • 使用固定的每日费用 $100 来估算餐饮、交通、活动和观光门票的成本

  • 将酒店和额外费用添加以返回最终估算

create_email 允许您创建将发送给客户的电子邮件摘要:

def create_email(self, trip_data: Dict, client_name: str) -> Dict:
        total_price = self.calculate_total_price(
            trip_data['recommended_hotels'],
            trip_data['itinerary']['duration']
        )
        prompt = f"""
        Dear {client_name},
        Based on your preferences, I'm pleased to present your travel plan:
        Destination: {trip_data['itinerary']['destination']}
        Duration: {trip_data['itinerary']['duration']} days
        Best time to visit: Month {trip_data['weather_analysis']['best_months'][0]['month']}
        Recommended Hotel: {trip_data['recommended_hotels'][0]['name']}
        Itinerary Overview:
        {trip_data['itinerary']['itinerary']}
        Estimated Total Cost: ${total_price}
        Please let me know if you would like any adjustments.
        """
        # Generate email using LLM
        response = self.llm(prompt)[0]['generated_text']
        return {
            'email_content': response,
            'total_price': total_price,
            'summary_data': {
                'destination': trip_data['itinerary']['destination'],
                'duration': trip_data['itinerary']['duration'],
                'hotel': trip_data['recommended_hotels'][0]['name'],
                'best_month': trip_data['weather_analysis']['best_months'][0]['month']
            }
        }

如我们所见,电子邮件将被结构化以包含成本(我们使用之前描述的方法)以及我们之前获得的其他信息。请注意,我们使用了一个模板。

记住,TravelPlanningSystem 是主控制器,它集成了所有 AI 代理以实现自动旅行规划:

class TravelPlanningSystem:
    def __init__(self):
        self.weather_agent = WeatherAnalysisAgent()
        self.hotel_agent = HotelRecommenderAgent()
        self.itinerary_agent = ItineraryPlannerAgent()
        self.summary_agent = SummaryAgent()

在第一步中,我们初始化我们的四个代理。每个代理将处理一个特定的任务。如果您注意到了,我们使用了一个模块化系统。其优势如下:

  • 每个组件独立运行,使系统可扩展

  • 组件可以更新或替换,而不会影响其他组件

  • 它遵循 单一职责原则(SRP)以实现干净的代码架构

在这一点上,我们可以开始设置——获取最佳酒店和最佳访问月份:

def setup(self, historical_weather_data: Dict, hotels_database: List[Dict]):
        # Initialize and train the models
        self.weather_agent.train(historical_weather_data)
        self.hotel_agent.add_hotels(hotels_database)

最后,您必须协调整个旅行并生成包含成本估算和行程安排的总结电子邮件:

def plan_trip(self, destination: Dict, preferences: str, duration: int, client_name: str) -> Dict:
        # 1\. Weather analysis and best time prediction
        weather_analysis = self.weather_agent.predict_best_time(destination)
        # 2\. Hotel search
        recommended_hotels = self.hotel_agent.find_hotels(preferences)
        # 3\. Itinerary creation
        itinerary = self.itinerary_agent.create_itinerary(
            destination,
            weather_analysis,
            recommended_hotels,
            duration
        )
        # 4\. Create summary email and calculate price
        trip_data = {
            'weather_analysis': weather_analysis,
            'recommended_hotels': recommended_hotels,
            'itinerary': itinerary
        }
        summary = self.summary_agent.create_email(trip_data, client_name)
        return {
            **trip_data,
            'summary': summary
        }

现在我们已经创建了多代理平台,我们必须执行它。main() 函数作为运行 旅行规划系统 的入口点。它通过以下方式演示了系统的功能:

  1. 初始化样本数据(天气历史和酒店)

  2. 设置和训练 AI 模型

  3. 执行旅行规划过程

  4. 打印生成的旅行摘要

我们向系统提供了有关天气、目的地、酒店等方面的各种信息。之后,系统被初始化并执行。此时,它打印旅行摘要详情和由 GPT-2 生成的个性化电子邮件,并显示估计的总旅行成本:

def main():
    # Example data with a full year of weather information
    historical_weather_data = […    ]
    # Sample hotel database
    hotels_database = […]
    # Initialize the system
    system = TravelPlanningSystem()
    system.setup(historical_weather_data, hotels_database)
    # Plan a trip
    destination = {
        'name': 'Rome',
        'latitude': 41.9028,
        'longitude': 12.4964,
        'attractions': ['Colosseum', 'Vatican', 'Trevi Fountain']
    }
    preferences = """Looking for a luxury hotel in the city center,
    preferably with spa facilities and fine dining options"""
    client_name = "John Smith"
    # Generate trip plan
    trip_plan = system.plan_trip(destination, preferences, duration=3, client_name=client_name)
    # Print results in a readable format
    print("\nTRAVEL PLANNING RESULTS:")
    print("-" * 50)
    print(f"Client: {client_name}")
    print(f"Destination: {destination['name']}")
    print("\nGenerated Email:")
    print("-" * 20)
    print(trip_plan['summary']['email_content'])
    print("\nEstimated Total Price:")
    print(f"${trip_plan['summary']['total_price']}")

确保只有当脚本直接执行时,main() 脚本才运行:

if __name__ == "__main__":
    main()

到目前为止,我们只需要对其进行测试。一旦运行了脚本,结果应该是这样的:

图 9.39 – 展示执行的截图

图 9.39 – 展示执行的截图

这个旅行规划系统是一个原型,展示了 AI 智能体如何协作来自动化现实世界的问题。

当然,可以对系统进行一系列改进,使其更有用:

  • 使用的数据是静态的(这是一个玩具示例)。你可以连接到多个 API 以获取实时数据,例如天气(OpenWeatherMap 或 AccuWeather)、酒店(Booking.com 或 Expedia API)和目的地(Google Places API 或 Yelp)。还可以添加扩展,如航班和交通(Google Flights API 或 Rome2Rio)。

  • GPT-2 已经过时了(我们使用它是因为它比其他模型小得多)并且没有针对旅行进行微调。你可以用更大的或针对旅行优化的模型替换 GPT-2。例如,你可以使用更大的模型,如 GPT-4 或 Claude,或者开源替代品,如 LLaMA。此外,开源模型可以在 Tripadvisor、Lonely Planet 或 Reddit 的真实旅行行程上进行微调。

  • 行程是通用的,不能适应不同类型的旅行者。你可以向旅行者询问不同的信息,例如预算偏好、他们喜欢什么样的活动(文化、冒险、美食、家庭友好型等),或者他们是否需要特殊住宿(轮椅、与老年人同行或宠物友好型)。这需要一个更大的模型,你也可以测试推荐模型。此外,还有实现多标准决策制定(MCDM)的方法和模型,以进行更复杂的排名。

在任何情况下,尽管这个系统很简单,但它让我们看到了几个有趣的因素:

  • 与使用一个大型的单体 AI 模型不同,该系统被分解为专门的智能体。这个想法对于现代软件设计来说非常有用。

  • 这个简单的例子模拟了多智能体 AI 平台在自动驾驶汽车、金融、医疗保健和机器人技术中的工作方式。实际上,多智能体协作是一个旨在考虑可扩展性、模块化和效率的系统,这对于现实世界的应用是必要的。

  • 该系统可以动态生成个性化推荐(尽管在我们的案例中是硬编码的,我们模拟了用户输入偏好时发生的情况)。

  • 该系统还分析了多个因素(天气、酒店和景点)并优化旅行计划。类似地做这件事的现代系统使用精确的机器学习模型(在我们的例子中,我们使用了随机森林),拥有庞大的数据库(在我们的案例中,我们模拟了一个酒店数据库),考虑用户偏好,并使用自动化系统响应用户(我们的电子邮件)。

尽管这是一个非常简单的系统,但我们可以思考一个类似的系统如何在其他各种行业中得到应用:

  • AI 医疗助手推荐治疗方案、优化医院日程安排并预测疾病风险

  • 基于用户偏好和购买历史推荐产品的 AI 购物助手

  • 用于自动驾驶汽车的多智能体 AI 系统(导航、行人检测或交通优化)

  • 由人工智能驱动的顾问,帮助制定投资策略、风险管理以及欺诈检测

  • 一个由人工智能驱动的城市规划师,优化交通、能源使用和公共交通路线

在本节中,我们探讨了如何创建一个多智能体系统。在下一节中,我们将讨论多智能体系统如何适应今天存在或正在进一步发展的各种商业模式。这将提供一个重要的视角,因为它将使你能够了解如何调整你的多智能体平台以满足企业的需求。

软件即服务(SaaS)、移动即服务(MaaS)、数据即服务(DaaS)和机器人即服务(RaaS)

在本节中,我们将探讨受最近人工智能进步影响的多种商业模式。虽然多智能体 LLM 代表了尖端技术,但它们的价值在于能够适应满足商业需求,使它们能够有效地打包、营销并交付给企业和消费者。考虑到这些系统开发和维护成本极高,读者了解收入模式非常重要,这样他们就可以思考、设计和开发与公司战略一致的产品。理解这些模式使我们能够理解多智能体系统不是一个独立的项目,而应该被视为一个产品,并且这个产品可以通过多种方式来营销。此外,LLM 是极其昂贵的产品,并且每个商业模式在持续更新、可扩展性和人工智能部署的灵活性方面都有其优势和劣势。同时,这些商业模式规范了技术访问,无论你是想开发人工智能模型还是作为客户。在产品开发之前必须做出这些选择(关于平台、商业模式等),因为成本不允许试错。商业模式的选择由产品的结构和多智能体系统,以及公司的经济可行性所定义。

软件即服务(SaaS)

SaaS 是一种服务模式,其中软件由提供商托管在云端,并通过互联网向用户提供服务。在传统模式中,软件提供给用户安装和本地使用(在用户的设备上)。另一方面,SaaS 允许通过互联网访问,通常是通过网页浏览器或移动应用。通常,SaaS 是通过订阅而不是一次性购买来提供的。SaaS 范式始于 1999 年,当时 Salesforce 推出了其客户关系管理(CRM)作为云托管服务。SaaS 现在是不同公司最广泛使用的销售范式,特别是对于企业对企业(B2B)应用。其受欢迎程度正在增长,预计未来几年 SaaS 软件的收入将不断增长。

SaaS 应用通常是为了托管在云端而构建的(它们被称为云原生)。开发这些应用的公司可以决定是否在自己的基础设施上托管,或者利用云服务提供商的基础设施(例如 Google Cloud、IBM Cloud、OVH、Aruba、亚马逊网络服务(AWS)和 Microsoft Azure)。鉴于对应用提供商的需求,一些提供商为托管这些应用创建了专门的基础设施,因此我们也谈论平台即服务(PaaS)。

在 PaaS 解决方案中,提供商通过专用基础设施托管硬件和软件,这些基础设施可供产品开发者使用。这允许开发者专注于编码,而无需担心维护或管理其背后的基础设施。该平台允许托管应用程序和数据,甚至训练模型,只留下编码工作给开发者。这已经使许多企业能够加速产品开发,他们设法避免了投资昂贵的基础设施(尽管广泛使用这些平台可能成本高昂,尤其是在应用是生成式 AI 时)。尽管 PaaS 简化了流程,但开发者被迫使他们的应用程序符合平台和环境的要求。这并不总是可能的,导致部署或其他问题。因此,出现了一种新的范式,使用户具有更大的灵活性、控制和适应性,尤其是在应用程序或业务需要时。这种范式被称为基础设施即服务(IaaS)并大约在 2010 年出现。在 IaaS 中,用户可以通过网络服务访问计算资源,从而能够根据需要租赁基础设施(服务器、网络和存储)。用户对基础设施的控制更多,而提供商则专注于硬件(例如 Google Compute Engine、DigitalOcean 和 Amazon Elastic Compute Cloud)。因此,PaaS 和 IaaS 可以被视为 SaaS 的扩展,或为需要支持生态系统的企业提供服务。

图 9.40 – 不同范式的比较(img/B21257_09_40.jpg)

图 9.40 – 不同范式的比较(arxiv.org/pdf/2311.05804)

因此,SaaS 应用程序被设计为可以通过互联网连接从必须连接到互联网才能访问应用程序的设备(未连接的设备无法访问应用程序,并且允许本地访问不是必需的)进行访问。软件是开发用来通过网络浏览器或特定应用程序(移动软件)使用的。某些 SaaS 应用程序(例如 Adobe Acrobat)可能要求用户在他们的计算机上下载并安装一个专用的客户端(一个轻量级程序,不是完整的应用程序,需要安装在本地 PC 上),但这通常是少数情况。SaaS 应用程序通常是一个 多租户软件架构,其中软件应用程序的单个实例(包括其数据库和硬件)为不同的用户账户(或多个租户)提供服务。租户就是所谓的软件用户,它是一个组织内的单个用户或用户组。

在 SaaS 中,拥有一个确保每个租户的数据被隔离且对其他租户不可访问的架构至关重要。这种方法通过使软件能够针对单一硬件和基础设施进行优化,然后由所有用户共享,从而降低了成本。它还允许实现更大的可扩展性、更易于定制的维护(提供商可以在自己的基础设施和单一架构上自行进行更新)。

SaaS 因此成为最广泛使用的范式之一,因为它具有许多优势:

  • 成本效益:客户无需承担任何前期成本,例如硬件或软件许可的费用。在 SaaS 中,客户可以选择按订阅或按使用付费。

  • 可扩展性:SaaS 对客户来说易于扩展,且不需要额外的硬件。同样,软件的结构使得扩展客户变得容易。在人工智能模型的情况下,客户不需要大型硬件,可以直接利用提供商提供的硬件。

  • 可访问性:客户可以通过互联网连接从世界任何地方访问应用程序。此外,使用网络浏览器,软件针对客户拥有的任何硬件进行了优化。SaaS 还通过使用模板、API 和框架,降低了客户访问人工智能的门槛(资源较少且对专业知识的需求较低)。

  • 集成和定制的便捷性:从资源和时间方面来看,开发者提供更新、安全补丁和维护要容易得多。通常以更简单的方式为客户提供定制管理的能力,同时保持控制。同样,对于 AI 系统,可以提供更新的模板。

  • 快速部署:SaaS 通过在市场上立即可用来减少部署和市场接入时间。

  • 数据和模型共享:模型和数据的访问可以轻松地同时允许来自不同团队或不同地点的用户,并且高效且有效地进行。

当然,SaaS 也有一些限制和缺点:

  • 对互联网连接的依赖:SaaS 需要稳定的连接,连接中断可能会停止关键流程并引发错误。农村地区和基础设施薄弱的国家可能无法覆盖。

  • 定制有限:SaaS 解决方案是在一个产品中尽可能覆盖更多业务的想法下开发的。通常,它们提供有限的定制选项,可能无法满足特定企业的所有需求。在 AI 系统的案例中也是如此;客户对模型的控制很少,模型可能无法满足客户的要求。

  • 数据安全和隐私问题:托管在第三方服务器上带来了数据泄露或未经授权访问的风险。此外,可能与欧盟等国家的法规不符(例如,数据必须存储在特定国家的服务器上)。训练或使用 AI 模型可能需要共享敏感数据,这可能违反 GDPR 或其他法规(以及额外的隐私风险)。

  • 供应商锁定:企业可能依赖于特定的 SaaS 提供商,然后由于成本和复杂性而无法迁移到其他平台。此外,不同的提供商可能会终止服务(或被收购),突然增加成本,或取消被认为至关重要的功能。随着时间的推移,SaaS 可能会变得昂贵,尤其是当基于订阅时(一些提供商随着用户数量的增加而收费更多)。

  • 性能问题:在多租户架构中共享资源可能导致高峰时段性能变慢。此外,可能会有意外的服务器停机或维护计划,这会损害业务(例如,如果维护在太平洋时间晚上进行,将干扰欧洲的业务时间),而客户对此无能为力。必须实时运行的 AI 系统可能存在延迟或性能问题(无论是在训练还是在推理)。此外,提供商可能不提供最先进的 AI,或者尚未实施(或者他们可能使用不适合客户需求的模型)。

  • 高计算成本:SaaS 对开发者来说有基础设施成本,在 AI 的情况下,这种成本可能更高(使用 GPU 或大存储成本)。其中一些服务对用户来说特别昂贵。

模型即服务 (MaaS)

MaaS 是随着大数据、AI 和 Web 3.0 的发展而产生的一种新范式。MaaS 是一种基于云计算的服务范式,为开发者和企业提供 AI 和 ML 模型以及相关的 IaaS。

MaaS 旨在简化那些既没有专业知识也没有基础设施来训练生成 AI 或一般模型的企业的 AI 访问。MaaS 通过简单的界面、API 或浏览器使用预训练的 ML 模型和算法。就像 SaaS 一样,模型的访问是通过互联网进行的(并且要求企业有互联网连接)。然后,提供商必须托管模型并允许开发者访问已训练的模型。开发者可以使用这些模型将 AI 功能添加到他们的系统和应用中。MaaS 通常是一个平台,用于托管在大量数据上训练或针对可能任务优化的模型。MaaS 减少了管理这些模型的复杂性(尤其是培训和部署),并允许开发者专注于使用模型或如何将它们集成到特定应用中。由于开发者不必从头开始训练这些模型,因此他们节省了时间和资源。因此,MaaS 在某些方面与 PaaS 和 IaaS 相似,但进行了一个额外的抽象级别,并专注于 AI 解决方案。从某种意义上说,MaaS 可以被视为 SaaS 和 PaaS 或 IaaS 之间的中间解决方案。它不仅提供了一种服务,还提供了一种基础设施,使定制产品的开发成为可能。

SaaS 和 MaaS 之间的另一个区别在于两种范式的底层架构。SaaS 侧重于应用程序(应用层),这些应用程序依赖于一个操作系统(无论是移动还是桌面应用程序)来运行,以及一个允许应用程序托管的层。在 MaaS 的情况下,架构侧重于需要特定框架来托管的模型。

图 9.41 – 传统技术与基于模型的技术堆栈的比较(img/B21257_09_41.jpg)

图 9.41 – 传统技术与基于模型的技术堆栈的比较(arxiv.org/pdf/2311.05804)

在 MaaS 中,以下元素通常存在:

  • 云计算:MaaS 基于云上的基础设施,其中维护和部署了各种模型。这使得对模型的访问变得容易,并实现了更大的可扩展性。

  • 模型训练和优化:MaaS(模型即服务)提供商负责在大数据集上训练大型模型。他们还负责整个生态系统,以实现模型更有效的利用。例如,他们可以提供不同大小的模型,包括针对特定应用的量化或微调版本。

  • API 和开发工具:MaaS 提供商还提供 API 和工具,允许开发者轻松地将模型用于其应用程序。目的是允许轻松地将模型集成到其他应用程序和基础设施中。因此,API 作为端点,接收数据,并返回预测。

  • 监控和分析:迄今为止,越来越多的关注点是如何在生产环境中监控模型。MaaS 提供商通常提供一系列工具来监控模型性能、识别问题存在、集成反馈或改进资源分配。

  • 可扩展性、安全性和隐私性:MaaS 提供商通过允许客户同时管理多个用户(从而根据需要分配不同的带宽、计算能力或存储)来关注其系统的可扩展性。同时,今天对隐私和安全性的关注越来越多(尤其是在有更多监管的情况下)。平台通常有一系列工具,可以增加集成其模型的应用的隐私性和安全性。

Hugging Face 是一个 MaaS 提供商的例子。Hugging Face 为计算机视觉、NLP、音频、视频等领域提供数千个预训练模型(来自公司本身、其他公司或用户)。这些模型托管在其模型中心,可以通过 API 使用或本地安装。因此,不想下载模型的用户可以使用推理 API,而不需要拥有管理模型所需的基础设施(此 API 使用按使用付费系统)。没有专业知识或资源的开发者可以直接使用端点 API,将其应用程序中的 AI 模型直接集成。此外,Hugging Face 还提供了一个平台,用于托管和部署模型以及应用程序,扩展 MaaS 功能,并为希望使用自定义模型的客户提供灵活性。Hugging Face 还提供工具以提高模型的可扩展性,开源库以促进模型开发或集成(例如,Transformers、Datasets、Diffusers、句子嵌入等),以及提供论坛以促进用户交流、用户教育资源和其他服务。还有其他 MaaS 提供商,例如 Google AI(提供 NLP(自然语言 API)、视觉(视觉 API)、语音转文本、翻译或使用 Vertex AI 的自定义模型训练)和 AWS(提供语言、图像和文本(例如,AWS Comprehend、Rekognition 和 Translate)的预训练模型或自定义模型的基础设施)。

MaaS 在 AI 领域具有以下优势:

  • 简化的模型开发和部署:MaaS 降低了使用生成式人工智能的技术门槛。公司不需要对技术或不同算法有专长的开发者,因为大多数模型都是通过端点交付的。这使得公司能够专注于其产品的应用和模型集成。如果需要,MaaS 还简化了为应用微调模型的方法。与 SaaS 不同,MaaS 针对整个 AI 工作流程进行了定制,并提供用于部署、训练、管理和扩展模型的工具,从而为有兴趣使用人工智能的公司提供更好的支持。

  • 高性能和可扩展性:云计算的使用促进了系统扩展。实际上,使用人工智能可能需要高昂的成本和大量的资源(尤其是在使用大型语言模型时),而 MaaS 通过便于访问大型模型而无需不同企业承担初始进入成本,从而实现了更好的资源管理。通常,用户根据其需求支付消费费用并接收计算服务,从而实现更好的性能和可扩展性。由于 MaaS 针对人工智能工作负载进行了优化,因此当计算需求波动时,它可以轻松扩展(SaaS 通常侧重于分配可变数量的用户,但用户对计算的需求可能因模型的不同使用而不同)。

  • 共享知识和协作:MaaS 建立在收集大量数据集和训练大型模型的基础上。这些预训练模型随后可以被对将模型适应特定应用感兴趣的开发商微调。这意味着开发商需要收集的数据量更少,也不必从头开始训练大型模型。这节省了资源和成本(微调的计算成本远低于预训练)。此外,MaaS 允许标准化,从而降低了使用这些模型所需的技术知识,并允许轻松获取信息和教程。模型还可以在平台上由社区共享,这些平台上也交换信息和经验(这促进了协作环境并加速了新模型的发展)。

  • 商业支持:MaaS 采用灵活的支付模式,例如基于订阅的支付方式,您只需为当前消费付费。通常,这种解决方案对许多小型企业来说既经济又实惠。对提供商来说很方便,因为一旦他们选择了一种技术并将其集成到他们的产品中,用户就会保持忠诚。模型集成使企业能够以简单且经济的方式获得洞察力(用于预测或其他预测的模型、报告编写和可视化)。

  • 灵活性:MaaS 为大量应用程序提供模型,并允许企业集成大量潜在模型,提供广泛的灵活性(例如,自然语言处理、计算机视觉、时间序列等众多其他应用)。此外,开发者可以快速测试许多预训练模型,而无需更改设置(例如,Hugging Face 提供了数千个只需少量管道即可使用的模型)。同样,MaaS 提供商通常提供许多工具来简化 AI 生命周期(数据标注、数据格式集成、监控工具等),从训练到部署。

MaaS 是一种新的范式,生成式 AI 领域也在积极发展中,因此存在需要解决的一些挑战和可能的缺点:

  • 安全和隐私:通常,在模型训练过程中会传输大量数据,这可能会被拦截。此外,基于敏感数据训练的模型最终可能会输出敏感数据。这些模型也可能是在受版权保护的数据上训练的,而使用此类数据进行训练的立法并不完全明确。因此,坚持特别受监管行业的组织可能不会采用 MaaS。数据是这些模型的基础,但模型可能是基于低质量数据进行训练的,或者可能因为低质量数据而出现偏差。通常,没有关于这些模型训练数据的信息。在这些情况下,平台和这些模型的使用企业都可能面临罚款或其他监管。

  • 供应商锁定:MaaS 提供商使用专有工具和 API,这使得从一个提供商切换到另一个提供商变得困难(例如,更换提供商会复杂化模型集成或导出经过微调的模型)。这种困难可能会降低灵活性和创新,并使企业依赖于单一提供商。可能会有停机或服务中断,这会影响构建的应用程序。这也使得本地实验更加困难。

  • 有限的定制性:并非所有 MaaS(移动即服务)提供商都允许对预训练模型进行微调或修改。预训练模型可能不适合某些特定操作,或者企业可能需要控制超参数和基础设施。此外,MaaS 提供商可能会进行更改或计划更新,这可能会影响业务或不再允许其应用程序的一些核心功能。

  • 模型和结果的解释性:模型通常是一个黑盒,用户无法访问决策过程。特别是对于生成式 AI 模型,很难理解模型如何处理输入并得到输出。对于敏感应用,这可能会引起问题,特别是当模型产生幻觉或错误的输出时。此外,平台的缺乏透明度可能会影响诊断错误或了解如何纠正它们的能力。

  • 性能和成本:延迟指的是请求与相应响应之间经过的时间。模型的延迟取决于底层基础设施,在高峰使用期间可能会承受压力。在 MaaS 平台中的共享多租户环境在高峰使用时段可能会导致资源瓶颈。企业可能会遇到延迟显著增加的情况,使得他们的应用程序无法使用。MaaS 允许按需付费,但大规模训练或推理可能会迅速变得昂贵。

MaaS 对于许多企业来说仍然是一个不断发展的范式。例如,在医疗保健领域,由于存在大量数据,并且已经开发了许多模型,MaaS 可能会产生重大影响。这些模型可以在平台上提供,并在需要时由从业者或制药公司使用。显然,在医疗保健领域,数据安全和输出一致性至关重要(尤其是如果这些应用程序用于医院或其他医疗机构)。MaaS 在其他领域也在增长,例如金融、区块链和 Web 3.0。

图 9.42 – MaaS 中各种行业的应用( https://arxiv.org/pdf/2311.05804 )

图 9.42 – MaaS 中各种行业的应用(arxiv.org/pdf/2311.05804)

数据即服务(DaaS)

DaaS 是一种商业模式,无论用户地理位置或组织边界如何,都可以按需向用户提供数据。在 DaaS 中,数据存储在云端,客户可以通过向提供商支付订阅费来访问它(无论是否需要额外工具)。因此,DaaS 围绕数据是资产并且可以按需提供给用户的概念构建。这种访问可以通过平台、API 的使用或其他方式来实现。此外,提供商可以提供原始数据或经过标准化以供机器读取或准备好的数据。

人工智能模型以数据需求量大而闻名,获取高质量数据可能并不容易。因此,有一些参与者专注于收集难以获取的数据,然后将它们卖给其他参与者。例如,患者数据可能难以收集,一家公司可能会收集和处理数据,然后将数据卖给制药公司。或者,DaaS 允许公司创建新的商业模式,利用他们在正常运营期间收集的数据作为可以出售的资产。例如,一家收集了其用户数据的电信公司可以将匿名数据卖给零售商。这些数据通过安全门户出售,可以按访问次数收费或通过订阅收费。订阅通常是最受欢迎的方法,可以分为三种子类别:时间模型、基于数量的定价模型和按呼叫或数据类型付费的模型。

DaaS 提供商可能只是销售其收集的原始数据,但更常见的是,它还会对其进行处理,使其可以通过模型进行分析。一些 DaaS 提供商汇总不同的来源,进行处理,从而简化了客户的分析过程。实际上,这些数据的目的在于改善客户的业务流程和决策,或者允许客户训练他们的 AI 模型。

还可能存在双向性,其中提供商收集数据并将其协调以与自己的数据集成,然后再将其提供给客户端。通过将其与其他数据相关联,客户端可以从其自身数据中提取额外的价值。

DaaS 有一些优点:

  • 成本效益:DaaS 减少了客户构建和维护数据基础设施和团队的需求。由于其灵活性,它还降低了数据访问的成本。客户不需要存储数据;他们可以在需要时直接访问数据流。

  • 易于访问:按需提供数据允许实时访问,节省了获取数据信息的时间和专业知识。用户不需要了解数据及其背后的结构,但可以轻松学习如何使用它。此外,只要有互联网连接,客户端就可以始终访问数据。

  • 可扩展性:它易于扩展以适应不断增长的数据需求,而无需额外的基础设施投资。客户可以轻松选择他们需要或能够处理的数据工作量。

  • 集中式数据管理:DaaS 实现了一致和集中的数据存储,减少了数据的不一致性和冗余。这简化了数据治理并符合法规要求。

  • 专注于核心活动:DaaS 节省资源和时间,使企业能够专注于从数据中提取价值,而不是管理数据。此外,它还促进了不同团队成员和协作者的更好合作,他们可以访问相同的数据(以相同的格式)。

  • 与其他服务的集成:DaaS 使数据与业务中的其他服务集成变得容易,尤其是在分析平台、可视化工具和其他云服务方面。同样,它还促进了数据集的定期更新,并使用户能够访问最准确和最新的数据。

  • 数据质量:由于数据集中,数据质量往往得到改善。一旦这些数据经过测试,如果没有更新,就无需进一步测试。

DaaS 的缺点与其他与云计算相关的模型类似:

  • 数据安全和隐私风险:显然,数据在云上的位置可能意味着敏感和专有数据可以被第三方访问或面临泄露风险。提供商必须遵守日益严格的法规。保护基础设施的成本正在增加,数据盗版攻击也在上升。此外,尽管数据以匿名方式出售,但在某些情况下,有可能重建信息。

  • 对提供商的依赖性:DaaS 导致对外部提供商的临界数据产生依赖。提供商端的服务中断或故障会影响客户以及所有与访问此数据相关的服务。客户通常可以访问数据流,但不会下载数据,因此可能会被切断对其业务必要的数据。

  • 有限的定制性:DaaS 可能无法提供所需格式的数据或具有正确的粒度。提供商有提供对尽可能多的客户有用的数据的兴趣,但特定客户可能有不同的需求。不合适的格式使得将其集成到现有系统或自己的工作流程中变得更加复杂,需要承担适应系统或数据的成本。

  • 质量保证:在 DaaS 中,数据的准确性方面的质量至关重要,低质量的数据可能导致决策失误或相关服务中的错误。数据的质量、准确性和可靠性取决于提供商。因此,提供商必须确保数据的相关性、更新性和高质量。

  • 延迟和性能问题:通过互联网访问数据可能导致引入延迟(尤其是在连接不好或数据集非常大时)。此外,这种延迟如果数据流嵌入到其他服务中,可能会降低性能。

结果即服务(RaaS)

RaaS,或 OaaS,是近年来发展起来的一种新范式。RaaS 是一种商业模式,服务提供商提供特定的结果或成果,而不是提供工具、平台或原始数据。这种模式在数据分析、人工智能和自动化等领域引起了人们的关注。在 RaaS 中,提供商使用人工智能(包括 LLMs 和代理)为顾客提供个性化的见解。虽然提供商进行整个分析,但客户可以专注于业务洞察,无需专门的技术人员。一般来说,客户不是一次性支付服务费用,而是通过订阅定期接收分析。

由于客户越来越要求模型的价值(企业对模型获得的价值比对额外工具的兴趣更大),RaaS 专注于提供结果,而不是模型(或数据)。此外,客户正在寻找降低采用技术成本但保留其价值的方法,因此 RaaS 寻求将企业的初始成本降至最低。提供商专注于确定实现结果所需的技术或工具,而客户则说明他们的需求和需求。

RaaS 的目的是建立客户忠诚度,因此提供商有每个兴趣自动化分析过程。因此,可以设想 AI 代理成为这种商业模式的新核心组件。LLM 本身能够几乎瞬间生成可能的报告,从而为客户生成见解。这些报告可以使用 LLM 进行个性化,并提供针对客户的定制见解。添加工具和数据库既可添加定量组件,又可扩展 LLM 的功能。然后,代理允许自动和常规地完成任务。实际上,代理可以分析大量数据,并可以补充额外的模型。生成的报告(甚至演示)可用于做出明智的决策。

因此,RaaS 具有以下优势:

  • 以结果为导向的方法:企业只为结果(以及交付的价值)付费,而不是为工具、基础设施和专业知识付费。这降低了企业的风险,因为它对使用软件或进行分析没有责任。

  • 成本效益:对于客户来说,无需花费金钱来构建基础设施和专业知识。相反,服务提供商可以自动化流程并降低成本(对于小企业来说可能相当昂贵)。此外,客户可以以商定的价格采用订阅计划(附带的好处是结果导向的定价模型直接将成本与实现的结果相匹配),而服务提供商则获得稳定的月收入。

  • 关注核心竞争力:由于公司不必投资资源来构建和维护系统或管理流程,RaaS 提供了巨大的时间优势。这也允许企业实施新能力,只需从提供商那里执行。然后,客户可以专注于其核心竞争力,并将结果直接纳入其流程中。

  • 可扩展性、准确性和灵活性:该系统具有可扩展性和灵活性,因为提供商可以为不同的客户重复使用这项技术。由于他们的支付或声誉取决于服务的成功,因此提供商有动力提供高质量的结果。

RaaS 也可能存在一些劣势:

  • 控制权丧失:客户对如何实现这些结果的控制有限。他们无法跟踪过程或诊断过程中出现的潜在问题。此外,还可能存在客户可能没有注意到的合规性、质量或道德实践方面的潜在问题。总的来说,RaaS 不促进透明度,它依赖于客户对提供商的信任。

  • 对提供商的依赖:对于客户来说,RaaS 意味着对服务提供商的高度依赖,这可能导致供应商锁定、更换供应商困难或更换供应商成本高昂。任何提供商方面的失败或低效都会直接影响客户运营。在这些情况下,客户的选择有限。

  • 数据安全和隐私风险:敏感数据可能需要与服务提供商共享,从而产生隐私和安全方面的担忧。由于监管规定,企业可能无法共享这些数据,这可能导致潜在的安全漏洞和巨额罚款。同时,如果敏感数据被截获,企业可能会面临严重的声誉损害或罚款。因此,RaaS 服务提供商需要承担大量成本来维护系统安全、数据存储和连接。

  • 衡量结果复杂性:定义明确、可衡量的结果可能具有挑战性,尤其是在目标或分析复杂的情况下。客户和提供商之间的期望不一致可能导致关于是否实现结果的争议。这些争议可能变成昂贵的诉讼,并影响提供商的声誉。

  • 潜在的高成本:一方面,RaaS 可以降低前期成本,但从长远来看,这项服务对于企业来说可能会变得昂贵。此外,还可能产生进一步分析的成本,或者如果性能和目标不一致,也可能产生额外成本。

  • 有限的定制性:RaaS 解决方案可能由广泛的应用定义,可能无法满足企业特定的、细分的需求。服务提供商有自动化任务和创建对最多客户有用的解决方案的强烈兴趣。这意味着特定客户的需求可能需要额外成本,可能不会被解决,或者可能不被提供商充分理解。

  • 质量保证挑战:提供商有降低成本的兴趣;这是通过自动化和尝试实现适合所有客户的解决方案来实现的。提供商可能会为了快速实现结果而走捷径,这可能会损害长期价值。

在任何情况下,RaaS 都是一个不断发展的商业模式,尤其是在对 AI 和生成式 AI 的兴趣日益增长的情况下(许多企业希望整合 AI 服务,但既没有专业知识也没有基础设施来实现这一点)。许多公司只对模型的结果(如维护预测或患者的预后)感兴趣,而不是模型本身。许多企业会对结果进行定制,以满足他们的特定需求,而不需要开发整个流程。因此,随着竞争加剧,不同的提供商开始为不同类型的行业提供高度专业化的产品。这推动了创新,因为公司努力满足目前尚未满足的需求。随着提供的产品增多,客户的需求也将不断发展,使公司能够专注于改善其业务的关键要素。

不同范例的比较

我们可以将范例的选择总结如下:

  • SaaS:当提供商希望通过订阅提供稳定和可预测的收入流时,应选择 SaaS;他们的产品可扩展到大量客户(从而降低解决方案的成本),易于支持更新和维护,他们有利用云基础设施来最小化硬件成本的能力,可以保证频繁的软件改进,并确保客户忠诚度。当客户需要快速访问软件而不必投资硬件或维护时,应选择 SaaS;软件的灵活性和可扩展性至关重要,或者他们更愿意按订阅方式支付软件费用而不是进行大量前期投资。当客户更喜欢由外部提供商处理更新、维护和安全时,或者他们对远程可访问的应用程序感兴趣(例如,他们有分布在不同国家或不同地点的团队),SaaS 也是一个不错的选择。使用 SaaS 的例子包括 Salesforce(一个在各个行业广泛使用的基于云的 CRM 系统)、Microsoft 365(通过云订阅提供 Word、Excel 和 Teams 等生产力工具)、Adobe Creative Cloud(提供 Photoshop 和 Illustrator 等创意工具的访问权限,并持续进行云更新),以及 Slack(一个由分布式团队用于消息和协作的通信平台)。

  • MaaS: 当提供商能够与其他合作伙伴(或拥有稳固的基础设施)降低模型交付成本时,应考虑采用 MaaS;如果他们已经开发出高性能的 AI/ML 模型,这些模型可以服务于多个行业(例如,医疗保健、金融或零售),希望在不共享算法的情况下货币化开发出的模型或专业知识,并且能够安全可靠地保证模型访问,也应考虑 MaaS。当用户需要高级 AI/ML 模型但缺乏内部构建或训练的资源,或者更愿意外包模型维护、再培训和优化而不是内部管理时,应考虑这些解决方案。当成本效益和灵活性是优先考虑的因素时,特别是对于正在尝试 AI/ML 的初创公司和企业,以及当 AI/ML 驱动应用的上市时间至关重要时,也应考虑这些模型。使用 MaaS 的例子包括 OpenAI(通过 API 提供 GPT 模型的访问权限,用于文本生成或摘要等任务)、Google Cloud AI 平台(提供翻译、视觉、语音识别等模型)、AWS SageMaker JumpStart(允许企业快速部署预训练模型,用于欺诈检测等任务),以及 Hugging Face(通过其推理 API,提供数千个开源模型的托管访问权限)。

  • DaaS: 如果提供商能够访问高价值、独特的数据集,这些数据集可以惠及多个行业,他们希望利用对数据在决策和数据分析中日益增长的依赖性,他们希望为公司创造额外的商业机会(例如,销售随着时间的推移所获得的数据),他们能够确保符合数据保护法规(例如,GDPR 或 CCPA),他们拥有进行数据共享的基础设施,或者他们提供(或打算提供)超出原始数据的价值,例如见解、可视化或与工具的集成,应选择 DaaS。如果客户需要大量数据但不想投资于存储和处理基础设施,他们的业务依赖于外部或专业数据集(例如,市场数据、天气数据、地理位置数据、财务数据、医疗保健数据等),他们更喜欢访问不同数据集的灵活性和可扩展性,或者他们不想处理数据合规性、维护和安全,应考虑 DaaS。例子包括 Snowflake(一个云数据平台,允许组织之间安全地共享数据)、Quandl by Nasdaq(为分析师和机构提供金融、经济和替代数据)、Clearbit(提供 B2B 数据以丰富销售和营销)、以及 Copernicus 的气候数据存储(提供用于科学和商业用途的环境和气候数据集)。

  • RaaS:如果提供商拥有适当的基础设施来保证向客户提供可靠和可衡量的结果,并倾向于通过专注于提供价值和结果来区分自己,能够衡量性能并向客户保证结果,并且有专业知识来减轻风险和保证性能,他们可能会考虑 RaaS。当客户希望实现特定结果而不需要管理底层流程、基础设施或技术;当他们的重点是结果(例如,性能改进或运营效率)而不是工具或输入;当他们希望通过仅支付成功的成果或结果来最小化风险;当他们缺乏实现某些复杂和特定结果的专业知识;或者当他们希望降低成本并在一段时间内分散成本时,他们应该选择 RaaS。使用 RaaS 的公司的例子包括 Pymetrics(基于神经科学和 AI 提供招聘建议,而不暴露内部机制)、Afiniti(使用 AI 优化呼叫中心配对并基于改进的性能收费)、Uptake(在工业环境中提供与正常运行时间或效率提升相关的预测性维护)和 ZS Associates(在医疗保健和制药领域提供基于 KPI 和性能改进的分析驱动解决方案)。

下表提供了每个范例对提供商和用户的优缺点总结:

类别 SaaS MaaS DaaS RaaS
优点(****提供商) - 可重复收入模式。- 可扩展的基础设施。- 更容易的软件更新。- 成本效益的开发生命周期。 - 使 AI/ML 模型货币化。- 可扩展的计算资源分配。- 支持医疗保健和金融等各个行业。- 减少基础设施需求(例如,云托管 ML 模型)。- 扩展到利基 AI/ML 应用的机会。 - 数据货币化机会。- 数据集中管理。- 可预测的收入。- 利用现有数据集的能力。- 为不同行业提供服务时的灵活性。 - 稳定且可预测的收入流。- 鼓励基于结果的定价。- 在竞争市场中区分产品。- 使提供商能够专注于交付结果而不是销售产品。- 提高客户保留率。
优点(****用户) - 低前期成本。- 容易访问最新的软件版本。- 从任何地方都可以访问。- 订阅的灵活性以适应业务需求。 - 无需构建或训练即可访问高级模型。- 可扩展的计算能力以高效处理模型。- 使用模型进行预测或自动化的灵活性。- 通过避免构建内部 AI/ML 基础设施节省成本- 使 AI 应用更快上市。 - 容易且快速访问经过策划、可用的数据。- 数据系统的拥有成本较低。- 消除了需要大型数据存储/处理基础设施的需求。- 可伸缩性。 - 基于结果的支付降低了风险。- 专注于结果,无需担心底层基础设施。- 可预测的性能和价值。- 无需进行大量初始投资。- 在专家支持下简化实现预期结果。
缺点(****提供者) - 竞争激烈和客户流失。- 基础设施和更新的持续成本。- 与区域法规和合规性方面的挑战。 - 模型的初始开发成本高。- 确保 AI/ML 模型中的公平性、可靠性和合规性具有挑战性。- 管理模型在多种用例中的性能预期。- 资源密集型的模型更新和再训练。 - 数据使用中的隐私/安全问题。- 实时数据交付的基础设施。- 需要遵守复杂的数据法规(例如,GDPR)。 - 收入取决于结果的成功交付。- 为性能保证而支付的高前期成本。- 测量和问责制指标复杂。- 如果结果难以交付或期望不一致,则存在利润率降低的风险。
缺点(****用户) - 依赖互联网连接。- 数据安全和隐私风险。- 长期成本可能超过直接购买软件。 - 依赖第三方模型。- AI/ML 模型中可能存在偏差或错误。- 如果经常需要,可能会产生长期成本。- 有限的能力为高度特定的需求定制模型。- 在某些 AI/ML 应用中存在隐私问题。 - 对数据所有权和供应商锁定问题的担忧。- 可能存在高额的长期成本。- 可能过度依赖第三方数据。- 敏感数据的安全风险。 - 依赖于供应商以实现结果的成功。- 过程如何实现结果缺乏透明度。- 在合同期间修改结果的能力有限。- 可能不适合具有高度特定、非标准化需求的用户。- 如果结果定义不明确,成本可能会上升。

表 9.1 – 提供者和用户的优缺点

商业范式的选择非常重要。每个范式都会对用户和业务产生影响。找到正确的范式可以节省资源并增加收入。范式的选择会影响开发多智能体系统的技术选择。

摘要

在本章中,我们看到了如何将之前章节中讨论的工具添加到 LLM 中。我们了解到 LLM 具有规划和推理的能力,但在执行方面产生的结果较弱。LLM 能够生成文本,但与此同时,学习到的海量信息也允许它发展超越文本生成的技能。虽然要求 LLM 对图像进行分类是一种计算上的浪费,但 LLM 可以使用专门的模型来完成任务。正如我们通过 HuggingGPT 所看到的,一个模型可以调用其他模型来识别图像中的披萨。在这种情况下,我们看到了 LLM 调用多个模型,收集它们的输出,并对结果进行推理(注意,模型在图像中披萨的类型上达成一致)。然后 LLM 可以进行推理,选择需要运行的模型,收集输出,并观察任务是否完成。

这个概念使得彻底改变各种工业应用成为可能。例如,客户可以通过电子邮件请求更换商品,因为他们购买的商品尺寸太小。大型语言模型(LLM)能够理解投诉,制定计划并执行它。该模型可以使用工具来验证购买,另一个工具来查看是否备有所需尺寸的商品,软件来安排发货,一旦订单完成,就向客户回复他们的请求已经得到满足。因此,代理能够自动化各种任务,因为它们允许 LLM 使用完成任务所需的其它工具。正如我们所看到的,这种方法可以扩展到许多其他应用:法律领域的代理,化学和生物学研究中的代理,等等。例如,人工智能代理可以作为法律助理帮助撰写论文,协助教授创建讲座,或者帮助研究人员定义科学假设。

虽然这些看起来像是高级场景,但必须理解 LLMs 在推理方面的局限性,并且目前它们可以自动化简单任务,但还不能满足复杂的商业需求。为此,需要有人工监督,并且开发者需要意识到系统的局限性。此外,LLMs 消耗资源,这些系统可能计算成本高昂。可扩展性是想要采用代理的企业面临的主要问题之一。因此,在本章的最后部分,我们讨论了随着 LLMs 的到来而开放的多种商业范式。SaaS 是过去三十年中主导的经典范式;它是在互联网革命期间构思的,但在 AI 作为大众产品到来之前。DaaS 专注于 AI 和企业在做出明智决策时对高质量数据的需求。MaaS 致力于那些想要提供 ML 和 AI 模型的公司,而 RaaS 则仅关注这些模型的输出。SaaS 和这些范式之间存在明显的相似之处,但它们考虑了两个因素:AI 模型需要基础设施和资源来训练和使用,而开发和维护这些模型需要相当的专业知识。因此,MaaS 和 RaaS 允许企业减少在基础设施、培训和专业知识方面的初始投资。根据他们的需求和资源,提供者或客户的选择是不同的,因此我们提供了一张比较表和一些指导方针。

因此,在本章中,我们定义了在实践中什么是代理(或对于多代理平台而言,一组代理)以及这些代理如何被整合到商业活动中。换句话说,我们定义了一个基于代理的系统。这个系统不是一个孤立的实体;在下一章中,我们将关注代理周围的生态系统以及代理如何融入其中。

进一步阅读

第十章:构建人工智能智能体应用

在前一章中,我们讨论了大型语言模型如何通过使用其他工具来扩展其功能。我们还看到了一些示例,说明了同时使用多个智能体(而不是一个)如何解决更复杂的问题。我们广泛讨论了这些方法如何在各个行业中使用,以及它们如何对许多应用产生革命性的影响。然而,我们也指出了智能体的两个局限性:可扩展性和将智能体与不同工具连接的复杂性。

在本章中,我们将进一步探讨这些挑战,并展示如何克服它们。我们将从这两个限制开始。到目前为止,我们将多智能体系统视为在个人计算机上独立运行的实体。在前一章的最后部分,我们探讨了随着人工智能的出现而兴起的令人兴奋的新商业模式。智能体在未来各个行业中都准备发挥重要作用,但为了实现这一点,智能体系统必须为生产部署做好准备。将多智能体系统投入生产意味着我们必须解决之前提到的可扩展性和复杂性等问题,以避免损害客户体验。

在本章中,我们将采用渐进式方法。我们将使用 Streamlit,这是一个简单但灵活的框架,允许我们管理围绕智能体创建应用程序的整个流程。它允许我们快速原型设计我们的应用程序,测试不同的选项,直到达到概念验证。使用 Streamlit,我们可以无缝地与后端(智能体运行的地方)和前端(塑造用户体验的地方)一起工作,所有这些都在一个框架内完成。

接下来,我们将更详细地讨论使大型语言模型和智能体功能所需的全部操作。无论您是否有机会从头开始训练模型,本节都将帮助您了解如何提高可扩展性以及行业如何处理过程的复杂性。此外,我们将讨论异步编程和容器化,这两个概念不仅对扩展多智能体应用,而且对任何机器学习项目都很有用。

本章将涵盖以下主题:

  • Streamlit 简介

  • 使用 Streamlit 开发我们的前端

  • 使用 Streamlit 和人工智能智能体创建应用程序

  • 机器学习操作和大型语言模型操作

  • 异步编程

  • Docker

技术要求

本章的大部分代码都可以在 CPU 上运行。Streamlit 简介和Streamlit 前端部分不需要 GPU。需要安装的库如下:

  • Streamlit: 用于管理我们应用程序的前端和后端

  • pandas: 用于处理 DataFrame

  • Matplotlib: 用于绘制图表

  • Folium: 用于绘制地图

  • time: 用于监控运行时间

  • NumPy: 用于数值计算

  • pydeck: 用于地图表示

  • OpenAI:用于使用其 LLMs 构建代理

  • Sentence Transformer:用于执行嵌入

“使用 Streamlit 和 AI 代理创建应用程序”这一部分可以在 CPU 上运行,但最好是在 GPU 上运行。

OpenAI 库需要使用 OpenAI 令牌,您应该注册 OpenAI 以获取它。接下来的部分可以在 CPU 上运行,主要基于 AsyncIO 库的使用。代码可以在 GitHub 上找到:github.com/PacktPublishing/Modern-AI-Agents/tree/main/chr10。

Streamlit 简介

如果读者熟悉 Streamlit,他们可以直接跳转到“使用 Streamlit 和 AI 代理创建应用程序”这一部分。

公司在数据科学和人工智能方面投入了大量资金。训练的模型可以指导业务决策并提供不同的见解。训练模型、使用它和提取见解需要专业知识,并非每个人都有。一个真正对公司有用的模型必须提供结果,然后其他利益相关者也可以使用。例如,当您训练一个模型时,它应该生成其他人可用的结果。可以创建数据的静态可视化(导出图表),但它们只能传达有限的信息。有人可能会提供信息在 Jupyter 笔记本中,但并非每个人都能使用这样的工具。一个可能允许其他人更容易访问的选项是创建仪表板或网络应用程序。

这正是 Streamlit 发挥作用的地方。

从 Streamlit 开始

Streamlit 是一个网络应用程序框架,允许用户使用 Python 轻松直观地创建网络应用程序。它的库为后端和前端提供了许多内置组件。它还与领先的机器学习、图形和绘图库兼容。

本节的目标是了解 Streamlit 的工作原理以及它如何成为一个强大的工具。

Streamlit 的一个优点是它易于使用和安装。Streamlit 可以简单地从终端安装,并在 Anaconda 分发中可用:

pip install streamlit

使用 Streamlit 组织应用程序是一个简单的 Python 脚本,通常包含后端和前端。这个脚本可以在本地或云端运行。例如,my_app.py 应该包含构建网络应用程序所需的所有元素。在最简单的情况下,只需几行代码,我们就可以构建一个网络应用程序。一旦我们定义了我们的应用程序,在本地运行它就非常简单:

streamlit run my_app.py

我们需要做的是调用 Streamlit 和我们应用程序的名称(显然,如果我们使用终端,我们需要在正确的目录中)。实际上,脚本不必在您的本地目录中;它可以在互联网上。例如,我们的脚本在我们的 GitHub 仓库中,我们想在本地运行它:

streamlit run https://raw.githubusercontent.com/streamlit/my_apps/master/my_app.py

在底层,Streamlit 会遍历文件并按顺序执行它找到的元素。完成后,将初始化一个本地 Streamlit 服务器,并在默认的网页浏览器的新标签页中打开你的应用程序。请注意,我们编写的一切都是 Python 代码,不需要其他语言。当我们进行更改时,我们必须保存我们的源代码。Streamlit 会检测任何修改并提示我们重新运行应用程序。这允许我们快速迭代,并立即观察效果,确保编写和运行应用程序之间的无缝反馈循环。

简单应用程序的一个例子如下:

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt
# Title for the app
st.title("Simple Streamlit App with Box Plot")
# Create a sample DataFrame
data = {
    'Category': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C'],
    'Values': [10, 20, 15, 25, 30, 20, 35, 40, 45]
}
df = pd.DataFrame(data)
# Display the DataFrame
st.write("Here is the sample DataFrame:")
st.dataframe(df)
# Create a box plot
fig, ax = plt.subplots()
df.boxplot(column='Values', by='Category', ax=ax, grid=False)
plt.title("Box Plot of Values by Category")
plt.suptitle("")  # Remove the automatic subtitle
plt.xlabel("Category")
plt.ylabel("Values")
# Display the plot in Streamlit
st.pyplot(fig)

我们生成的应用程序简单地做了三件事:使用 pandas 创建一个 DataFrame,绘制它,然后生成箱线图。在几行代码中,我们创建了一个可在浏览器上访问的微型网络应用程序。一旦编写完成,我们只需运行它,然后 Streamlit 就会处理其他所有事情。

图 10.1 – 网络应用程序示例

图 10.1 – 网络应用程序示例

让我们更详细地看看代码块:

  • st.title:这是一个文本元素,允许我们显示应用程序的标题。在应用程序中始终包含它是好主意。

  • st.write:这被认为是 Streamlit 的瑞士军刀。其主要目的是写入文本和其他元素。在这种情况下,我们展示了如何将 DataFrame 以良好的格式写入到应用程序中。此外,这个元素是交互式的。换句话说,它的行为取决于它所接收的输入。write() 函数不仅限于文本,还可以与图像、其他 Python 元素(如列表和字典)、模板等一起使用。它还允许我们在想要编辑文本时插入 HTML 命令。

  • st.pyplot:这显示了一个 Matplotlib 图形——在我们的例子中是一个箱线图。正如你所见,我们首先生成了图形,然后调用 pyplot() 进行后续绘图。图形在显示之前就已经生成。换句话说,图形已经在内存中;我们需要 pyplot() 来在应用程序中向用户显示图形。实际上,我们也可以直接使用 Matplotlib 进行绘图,但这样做不推荐,因为它可能导致意外的行为。

注意,我们只展示了基本命令,但 Streamlit 非常灵活。例如,DataFrame 可以以不同的方式写入到应用程序中。使用 st.write() 只是一种方法:st.dataframe() 与 st.write() 做同样的事情,st.table() 允许我们静态渲染表格,直接写入 'df' 就像我们使用 st.write() 一样。建议使用内置方法,因为其行为已知,我们还可以使用额外的参数来处理输出。

例如,我们可以使用内置方法 st.dataframe() 提供的灵活性来突出显示 DataFrame 中的元素:

df = pd.DataFrame(data)
st.dataframe(df.style.highlight_max(axis=0))

图 10.2 – DataFrame 渲染风格的变化

图 10.2 – DataFrame 渲染风格的变化

此外,Streamlit 还使得将地图添加到我们的应用变得容易。只需提供坐标,st.map() 就能神奇地让我们在应用中拥有地图(一个可以放大和移动的地图)。在这种情况下,我们提供了西西里岛一些城市的坐标:

city_data = {
    'City': ['Palermo', 'Syracuse', 'Catania', 'Agrigento'],
    'latitude': [38.1157, 37.0757, 37.5079, 37.2982],
    'longitude': [13.3615, 15.2867, 15.0830, 13.5763]
}
city_data = pd.DataFrame(city_data)
st.map(city_data)

图 10.3 – 使用 Streamlit 绘制地图

图 10.3 – 使用 Streamlit 绘制地图

如所见,我们在我们的应用中添加了一些元素并做了一些修改(添加了地图)。每次我们修改代码时,都应该记得保存脚本中的更改;然后,我们进入我们的应用并按 R 键,这将使用更新重新加载应用。

如果有任何错误,Streamlit 将提供错误信息,指示我们需要纠正的内容。以下图示了一个错误示例(在这种情况下,关于要使用的变量名):

图 10.4 – 错误示例

图 10.4 – 错误示例

对于调试,我们广泛使用 st.write();这个简单的函数可以通过引导我们理解错误来打印几乎任何 Python 对象。例如,我们可以在这个情况下使用它。如我们所见,我们在列名中有一个错误(Latitude 应该是小写;因此,我们用正确的名称替换它):

st.write(city_data)

图 10.5 – 使用 st.write() 调试

图 10.5 – 使用 st.write() 调试

缓存结果

缓存允许我们的应用即使在从网络加载数据时也能保持性能(我们将在后面讨论如何从网络或用户那里添加数据)。它还允许它操作大型数据集或使用机器学习模型。到目前为止,我们一直在使用小型数据集,因此我们可以加载任何东西,但如果我们开始在应用中放置数百万参数的模型呢?我们的应用可能会崩溃。如果我们使用需要长时间计算的计算模型或其他元素,我们需要通过在内存中缓存结果并避免重复计算来优化我们应用的高效性。我们可以将缓存视为一种短期记忆,其中我们保存经常使用或认为有用的信息以保护。缓存允许我们重用这些信息并节省计算。如果我们有一个执行大型计算的功能,我们可以使用两种替代方案:

  • st.cache_data: 这是 Streamlit 中的一个装饰器,用于缓存函数的结果,以便在应用程序重新运行时(例如,当用户与小部件交互或应用程序重新加载时)无需重新计算函数。此装饰器建议用于缓存返回数据的计算。当函数返回可序列化的数据对象(例如,str、int、float、DataFrame、dict 或 list)时,应使用 st.cache_data。当函数用 @st.cache_data 包装时,第一次调用该函数时,Streamlit 会根据配置将其结果存储在内存或磁盘缓存中。在后续调用中,如果使用相同的参数,Streamlit 会返回缓存的結果,这比重新计算它要快得多。它通过防止重复工作来加快应用程序的速度,特别是对于执行时间较长的函数。如果函数的输入发生变化,Streamlit 将使缓存失效并重新计算函数。

  • st.cache_resource: 这是在 Streamlit 中引入的另一个装饰器,用于处理资源的缓存——具体来说,是指那些不依赖于函数参数但代表可重用资源的对象或昂贵的操作,这些资源可以在应用程序的生命周期内进行缓存。虽然 st.cache_data 用于缓存基于输入的计算结果或数据加载,但 st.cache_resource 被设计用来缓存诸如数据库连接、模型对象或其他创建或初始化成本高昂但每次函数调用不发生变化的任何对象。使用此装饰器来缓存数据库连接、机器学习模型、网络连接或任何需要在应用程序多次运行中重复使用的昂贵资源。如果一个对象或资源(例如,一个预训练模型)创建成本高昂,可以使用 st.cache_resource 来避免多次重新加载或重新初始化它。

例如,对于 st.cache_data,在以下代码中,我们模拟了一个慢速操作,并展示了缓存如何节省时间:

import streamlit as st
import time
# Use @st.cache_data to cache the result
@st.cache_data
def load_data():
    time.sleep(3)  # Simulate a slow operation (e.g., loading a large dataset)
    return "Data loaded!"
# Call the function
st.write(load_data())
in a similar way for st.cache_resource:
import streamlit as st
import time
# Example: A resource-intensive function (e.g., loading a model)
@st.cache_resource
def load_model():
    time.sleep(5)  # Simulate a slow operation like loading a model
    return "Model loaded!"  # This could be a model object in a real scenario
# Call the function
st.write(load_model())

在前面的代码片段中,在运行函数之前,Streamlit 会检查其缓存以查找之前保存的结果。如果找到了,它会使用该结果而不是运行函数;如果没有找到,它会运行函数并将其保存到缓存中。缓存会在执行过程中更新,尤其是在代码发生变化时。

默认情况下,Streamlit 不会在应用程序重新运行之间保存信息,但每次重新运行时,它都会从头到尾重新运行应用程序。通常,Streamlit 在每次交互时都会重新运行整个脚本(例如,当用户调整滑块或点击按钮时)。使用会话状态,您可以存储在重新运行期间持续存在的数据,这样在脚本重新运行时就不会丢失值。每个用户都有自己的独立会话状态,因此会话状态中存储的数据与其他用户隔离。您可以使用会话状态来存储诸如表单输入、计数器、身份验证数据或中间计算结果等。

让我们尝试构建一个制作购物清单的应用程序;我们将展示如何保存会话信息:

import streamlit as st
# Define a list of grocery items (the initial list of items to buy)
grocery_items = ['Apple', 'Banana', 'Carrot', 'Milk', 'Eggs']
# Streamlit app interface
st.title('Grocery List App')
# Text input to add a new item to the list
new_item = st.text_input("Add a new item to your grocery list:")
# Button to add the new item to the list
if st.button('Add Item'):
    if new_item:
        grocery_items.append(new_item)
        st.success(f"'{new_item}' has been added to your list!")
    else:
        st.warning("Please enter an item to add.")
# Display the current list of grocery items
st.write("### Items to Buy:")
for item in grocery_items:
    st.write(f"- {item}")

这是我们最初的应用程序;我们将在之后立即看到我们如何查看用户保存的信息:

图 10.6 – 购物清单应用示例

图 10.6 – 购物清单应用示例

如果我们通过点击添加项目来添加对象,它们将被添加到列表中(此时,信息尚未保存;它仅保留在当前会话中):

图 10.7 – 购物清单应用中添加对象的示例

图 10.7 – 购物清单应用中添加对象的示例

然而,如果我们按下R并重新运行我们的应用程序,我们将丢失这些信息,元素将消失(因为信息没有保存到任何地方)。

现在,让我们尝试session_state:

import streamlit as st
# Initialize session state for grocery_items if it doesn't exist yet
if 'grocery_items' not in st.session_state:
    st.session_state.grocery_items = ['Apple', 'Banana', 'Carrot', 'Milk', 'Eggs']
# Streamlit app interface
st.title('Grocery List App')
# Text input to add a new item to the list
new_item = st.text_input("Add a new item to your grocery list:")
# Button to add the new item to the list
if st.button('Add Item'):
    if new_item:
        # Append the new item to the list stored in session state
        st.session_state.grocery_items.append(new_item)
        st.success(f"'{new_item}' has been added to your list!")
    else:
        st.warning("Please enter an item to add.")
# Display the current list of grocery items
st.write("### Items to Buy:")
for item in st.session_state.grocery_items:
    st.write(f"- {item}")

当我们使用st.session_state时,我们添加的项目将在当前会话中保留。在第一次运行时,列表将包含初始元素,随着用户添加更多项目,列表将相应增长。

然而,一旦页面重新加载或会话结束,除非我们将数据存储在持久位置(例如文件或数据库),否则列表将重置。

图 10.8 – 更新后的列表

图 10.8 – 更新后的列表

虽然st.session_state允许在用户会话期间临时存储值——随着交互的发生逐渐填满——但在完整页面重新加载或应用程序重启时,这些数据会丢失。相比之下,st.connection使 Streamlit 能够维持对外部资源的持久访问,确保数据在会话和重新加载之间保持可用。这使得它非常适合需要与长期数据持续交互的应用程序,克服了内存会话状态的限制。st.connection允许维护和重用与外部服务的连接,并且在与每个用户交互时都高效地做到这一点。

让我们看看st.connection在实际中的工作方式:

import streamlit as st
conn = st.connection("my_database_sql")
df = conn.query("select * from my_beautiful_table")
st.dataframe(df)

在本节中,我们讨论了 Streamlit 应用程序的主要组件。在下一节中,我们将讨论如何美化我们的应用程序并改善用户体验。

使用 Streamlit 开发我们的前端

在本节中,我们将开始讨论一些允许我们改善与我们的应用程序交互时用户体验的元素。

我们将展示各种前端元素以及如何将它们组合成复杂的应用程序。

添加文本元素

为了改善用户体验,我们可以从改善文本元素开始。我们首先添加的元素如下:

  • st.title(): 这个函数设置 Streamlit 应用的主标题。它是最大的文本元素,通常用于应用的主要标题。每个应用都应该至少有一个标题,这在 GitHub 风格的 Markdown 中也有显示。这个函数显然接受一个字符串。

  • st.header(): 这个函数为您的应用添加标题。它比标题小,但仍然作为一个重要的部分标题突出。这也在 GitHub 中有对应的功能,目的相似。您可以添加一个属性divider,在标题下方显示一个彩色分隔符(我们可以指定颜色)。我们还可以添加一个help字符串,在标题旁边提供工具提示。

  • st.subheader(): 这个函数添加一个副标题,它比标题小,通常用于子部分或为内容提供额外的结构。副标题也可以有一个彩色分隔符,如果您需要的话。还可以添加一个help字符串。

下面是一些如何插入这些元素的示例:

st.title("Your Title Here")
st.header("Your Header Here")
st.header("Your Header Here", divider=True, help ="bla bla")
st.subheader("Your Subheader Here")

现在,我们可以在我们的应用中直接测试它们:

import streamlit as st
# Initialize session state for grocery_items if it doesn't exist yet
if 'grocery_items' not in st.session_state:
    st.session_state.grocery_items = ['Apple', 'Banana', 'Carrot', 'Milk', 'Eggs']
# Streamlit app interface
st.title('Grocery List App :banana: :apple: :egg:')  # Main title of the app
# Display a header for the section where the user can add items
st.header('Add new item')
# Text input to add a new item to the list
new_item = st.text_input("Type an item to add to your grocery list:")
# Button to add the new item to the list
if st.button('Add Item'):
    if new_item:
        # Append the new item to the list stored in session state
        st.session_state.grocery_items.append(new_item)
        st.success(f"'{new_item}' has been added to your list!")
    else:
        st.warning("Please enter an item to add.")
# Display a subheader for the current grocery list
st.subheader('Current Grocery List')
# Display the current list of grocery items
for item in st.session_state.grocery_items:
    st.write(f"- {item}")

这段代码展示了如何将风格元素开始添加到我们的应用中。以下图显示了这些改进后的结果:

图 10.9 – 更新后的应用

图 10.9 – 更新后的应用

在 Streamlit 应用中插入图片

接下来,我们开始定制我们的应用,添加一个标志和一张图片。为此,我们将使用几个元素:

  • st.set_page_config(...): 这个函数用于配置 Streamlit 应用的页面设置,例如页面的标题、favicon(浏览器标签中的图标)和布局偏好。在这种情况下,我们将使用它来添加一个小的图标,它将作为浏览器标签元素显示。

  • st.image(...): 这个函数在 Streamlit 应用中显示图片。它接受图片的 URL 或路径,并且可以通过设置use_column_width=True来调整图片宽度以适应屏幕。作为输入,st.image可以接受 URL(正如我们在这个例子中所做的那样)或指向本地图片的路径或numpy.array(图片可以以数字格式存在)。

    关键词之一是 caption,它允许我们直接为图片提供说明。然而,在我们的情况下,我们将单独添加说明。

  • st.caption(...): 这个函数为元素(如图片或图表)添加下方的简短说明或描述性文本。在我们的应用中,它提供图片的来源信息。

  • st.sidebar.image(...): 这个函数在侧边栏中放置一个图片,它将是应用左侧的可折叠菜单。侧边栏对于放置导航、设置或附加内容非常有用。

我们现在将插入一张图片:

# Set the page configuration to include a logo
st.set_page_config(page_title="Grocery List App", page_icon="https://github.com/SalvatoreRa/tutorial/blob/main/images/vegetable_basket_logo.jpg?raw=true")
# Display the title image
st.image("https://github.com/SalvatoreRa/tutorial/blob/main/images/vegetables.jpg?raw=true", use_column_width=True)
st.caption("Image from [here](https://unsplash.com/it/@randyfath)")
# Add logo to the sidebar
st.sidebar.image("https://github.com/SalvatoreRa/tutorial/blob/main/images/vegetable_basket_logo.jpg?raw=true", use_column_width=True)

上一段代码展示了如何使用适当的说明插入图片。以下图显示了结果:

图 10.10 – 应用外观的变化

图 10.10 – 应用外观变化

这是我们的浏览器图标:

图 10.11 – 浏览器图标

图 10.11 – 浏览器图标

到目前为止,我们已经探索了 Streamlit 的基本功能,并使用它们构建了一个简单且静态的应用程序。现在,是时候超越这些功能,开始探索使 Streamlit 应用程序动态、响应和与实际使用相连的因素。

创建动态应用程序

我们可以进一步修改我们的应用程序,使其更加动态。到目前为止,我们的用户只能将项目添加到列表中,然后显示列表。这个应用程序用处不大,所以我们希望使其更加动态,并允许用户添加数量。因此,我们将执行以下操作:

  • 允许用户添加要购买的项目。一旦添加了项目,就会创建两个滑块,分别代表用户家中拥有的数量和需要购买的数量。为了避免创建无限长的列表,我们将使用两列。此外,我们还将添加一个按钮来选择用户是否已取用该成分。

  • 制作一个交互式的表格显示,显示成分,包括购买的数量、已取用的数量以及是否已取用,以及一个显示已取用项目和缺失项目的完成条。

  • 在侧边栏中添加一个按钮以下载列表。

让我们从使用两列以结构化的方式显示杂货清单项目开始,确保更紧凑和视觉上平衡的布局:

data = []
for i, item in enumerate(st.session_state.grocery_items):
    with col1 if i % 2 == 0 else col2:
        st.markdown(f"**{item}**")
        quantity_at_home = st.slider(f"Quantity at home", 0, 12, st.session_state.quantity_at_home[item], key=f"home_{item}")
        st.session_state.quantity_at_home[item] = quantity_at_home
        quantity_to_take = st.slider(f"Quantity to take", 0, 12, st.session_state.quantity_to_take[item], key=f"take_{item}")
        st.session_state.quantity_to_take[item] = quantity_to_take
        taken = st.checkbox(f"Taken", st.session_state.taken[item], key=f"taken_{item}")
        st.session_state.taken[item] = taken
        data.append([item, quantity_at_home, quantity_to_take, "Yes" if taken else "No"])

对于每个项目,我们根据索引 i 是偶数还是奇数来确定它是否应该放在第一列 (col1) 或第二列 (col2) 中。这确保了项目在两列之间均匀分布,防止出现长的垂直列表。

在选定的列中,项目名称使用 st.markdown() 以粗体显示。名称下方创建了两个滑块:一个用于用户家中拥有的数量,另一个用于需要携带的数量。每个滑块根据项目名称分配一个唯一的键,以确保正确跟踪和持久化值。这些滑块的值存储回会话状态,以便在应用交互中保持更新。此外,每个项目还包括一个复选框。每个项目的收集数据,包括其名称、选定的数量以及是否已取用,被附加到数据列表中。

图 10.12 – 应用重设计

图 10.12 – 应用重设计

注意到应用程序是交互式的(我们可以与滑块交互):

图 10.13 – 交互元素

图 10.13 – 交互元素

前面的图示展示了如何插入交互元素以及我们如何与之交互。Streamlit 在后台允许这样做,无需我们编写这些复杂元素,我们可以使用简单的命令。

我们可以显示表格:

df = pd.DataFrame(data, columns=["Name", "Quantity at Home", "Quantity to Take", "Taken"])
st.table(df)

图 10.14 – 获得表格

图 10.14 – 获得表格

在这一点上,我们可以创建我们的进度条:

# Progress bar
taken_count = sum(1 for item in st.session_state.taken.values() if item)
total_items = len(st.session_state.grocery_items)
progress = taken_count / total_items if total_items > 0 else 0
st.subheader("Grocery Completion Progress")
st.progress(progress)
st.write(f"{taken_count} out of {total_items} items taken ({progress*100:.2f}%)")

图 10.15 – 进度条

图 10.15 – 进度条

接下来,我们定义了一个函数 generate_pdf(),它创建一个包含购物清单数据的 PDF 文档,并允许用户下载它:

# Function to generate PDF
def generate_pdf():
    pdf = FPDF()
    pdf.set_auto_page_break(auto=True, margin=15)
    pdf.add_page()
    pdf.set_font("Arial", size=12)
    logo_path = "logo.jpg"  # Add logo to PDF
    response = requests.get(logo_url)
    with open(logo_path, "wb") as f:
        f.write(response.content)
    pdf.image(logo_path, 10, 10, 30)  # Position and size of the logo
    pdf.cell(200, 10, "Grocery List", ln=True, align='C')
    pdf.ln(20)  # Added extra spacing to prevent text overlapping the logo
    for index, row in df.iterrows():
        pdf.cell(0, 10, f"{row['Name']} - At Home: {row['Quantity at Home']} - To Take: {row['Quantity to Take']} - Taken: {row['Taken']}", ln=True)
    pdf_output = os.path.join(os.getcwd(), "grocery_list.pdf")
    pdf.output(pdf_output)
    return pdf_output
# Directly download the PDF when the button is clicked
if st.sidebar.button("Download List as PDF"):
    pdf_file = generate_pdf()
    with open(pdf_file, "rb") as f:
        st.sidebar.download_button("Download Grocery List PDF", f, file_name="grocery_list.pdf", mime="application/pdf", key="download_pdf", on_click=None)

首先,我们使用自动分页的 FPDF 对象初始化一个新的页面,并将字体设置为 Arial,字号为 12 以保持格式的一致性。为了增强 PDF 的视觉效果,generate_pdf() 函数从指定的 URL 下载一个标志,将其本地保存为 logo.jpg,并将其嵌入到页面的左上角。接着添加一个居中的标题“购物清单”,并留出一些空白以确保文本不会与标志重叠。然后,该函数遍历存储在 DataFrame (df) 中的购物清单,添加每个项目的名称、家中和要携带的数量,以及该项目是否已被标记为已取。一旦文档内容填充完毕,它就被保存在当前工作目录下,文件名为 grocery_list.pdf,并返回。

图 10.16 – PDF 按钮

图 10.16 – PDF 按钮

这里是生成的 PDF:

图 10.17 – 获得的 PDF 文件

图 10.17 – 获得的 PDF 文件

我们的用户可能想要添加备注;为此,我们可以利用 Streamlit 允许添加其他页面以创建备注部分的事实。请注意,我们现在有一个可以通过侧边栏访问的第二页。这样,我们可以输入备注并保存它们:

elif page == "Notes":
    st.title("Notes")
    st.session_state.notes = st.text_area("Write your notes here:", st.session_state.notes)
    if st.button("Save Notes"):
        st.success("Notes saved successfully!")

图 10.18 – 向应用添加另一页

图 10.18 – 向应用添加另一页

现在,我们还可以注意到信息已经更新到我们的 PDF 中:

图 10.19 – 更新的 PDF

图 10.19 – 更新的 PDF

如果我们的用户想知道最近的超市在哪里,我们可以在我们的应用中添加以下功能:

elif page == "Find Supermarkets":
    st.title("Find Nearby Supermarkets (OSM)")
        # Get user's location
    location_input = st.text_input("Enter your location (City, Address, or Coordinates):")
    if st.button("Find Supermarkets") and location_input:
        geolocator = Nominatim(user_agent="grocery_app")
        location = geolocator.geocode(location_input)
        if location:
            st.success(f"Location found: {location.address}")
            # Create map
            m = folium.Map(location=[location.latitude, location.longitude], zoom_start=14)
            folium.Marker([location.latitude, location.longitude], tooltip="Your Location", icon=folium.Icon(color="blue")).add_to(m)
            # Use Overpass API to find nearby supermarkets
            overpass_url = "http://overpass-api.de/api/interpreter"
            overpass_query = f"""
            [out:json];
            node"shop"="supermarket";
            out;
            """
            response = requests.get(overpass_url, params={'data': overpass_query})
            data = response.json()
            for element in data["elements"]:
                lat, lon = element["lat"], element["lon"]
                name = element.get("tags", {}).get("name", "Unnamed Supermarket")
                folium.Marker([lat, lon], tooltip=name, icon=folium.Icon(color="green")).add_to(m)
            folium_static(m)
        else:
            st.error("Location not found. Please try a different input.")

在代码中,我们向 Streamlit 应用添加了一个新页面,用户可以使用 geopy 库中的 Nominatim 地理编码器将位置输入转换为经纬度坐标,以查找附近的超市。如果找到有效的位置,我们向用户确认,并使用 Folium 创建一个以给定坐标为中心的交互式地图。添加一个标记来指示用户的位置。接下来,我们使用 Overpass API,该 API 查询 OSM 数据,以找到半径为 5 公里的超市。我们向 Overpass API 发送请求,并解析 JSON 响应以提取附近超市的坐标和名称。然后,每个超市都被添加到地图上的绿色标记。最后,我们使用 folium_static 在 Streamlit 应用中显示生成的地图。如果位置输入无效或未找到,我们显示一个错误消息,提示用户再次尝试。

图 10.20 – 查找超市页面

图 10.20 – 查找超市页面

当我们点击 查找超市 时,我们得到以下内容:

图 10.21 – 超市地图

图 10.21 – 超市地图

现在我们知道了如何构建应用程序,我们可以使用代理来构建一个。

使用 Streamlit 和 AI 代理创建应用程序

在本节中,我们将探讨将第九章中描述的多代理系统集成到 Streamlit 应用程序中。在这里,我们只描述我们更改的代码部分;结构保持不变。在前一章中,我们构建了一个脚本,允许定义旅行程序;在本章中,输出相同,但系统被封装在应用程序中。换句话说,我们的应用程序将在浏览器中运行,甚至可以供不懂得编程的用户使用。

作为简要回顾,多模型旅行规划系统是一个由 AI 驱动的助手,它集成了多个专业模型以生成个性化的旅行计划。它包括四个关键代理:

  • WeatherAnalysisAgent:使用历史天气数据预测最佳的旅行月份

  • HotelRecommenderAgent:使用转换器模型找到符合用户偏好的住宿

  • ItineraryPlannerAgent:使用 GPT-2 生成详细的每日旅行计划

  • SummaryAgent:创建专业的旅行总结和成本估算

系统遵循结构化的数据流,其中用户输入他们的目的地、偏好和持续时间,代理协作以提供完整的旅行计划。核心 AI 模型包括用于天气预测的RandomForestRegressor、用于酒店推荐的SentenceTransformer以及用于行程和总结生成的 GPT-2。

为了更好地理解旅行规划系统的内部结构,本节提供了三个 UML 图。这些可视化展示了本章所述应用程序的架构、执行流程和系统交互:

  • WeatherAnalysisAgent和ItineraryPlannerAgent)、底层模型(RandomForest、SentenceTransformer和OpenAI GPT)以及连接用户界面到后端逻辑的 Streamlit 应用程序:

图 10.22 – 多模型旅行规划系统的结构 UML 图

图 10.22 – 多模型旅行规划系统的结构 UML 图

  • 活动图:活动图描述了应用程序的控制流程,从用户输入收集到生成完整的旅行计划。它说明了每个代理是如何被触发的以及它们的输出是如何合并的:

图 10.23 – 多模型旅行规划系统的 UML 活动图

图 10.23 – 多模型旅行规划系统的 UML 活动图

  • 序列图:最后,序列图概述了 Streamlit 前端、数据库和 AI 代理之间的基于时间的交互。它显示了方法调用的顺序、交换的数据以及系统等待响应的点。它清楚地说明了每个代理何时以及如何被调用:

图 10.24 – 多模型旅行规划系统的 UML 序列图

图 10.24 – 多模型旅行规划系统的 UML 序列图

首先,我们开始导入所需的库:

import streamlit as st
import numpy as np
import pandas as pd
import pydeck as pdk
import openai
from sklearn.ensemble import RandomForestRegressor
from sentence_transformers import SentenceTransformer
  • streamlit: 我们用于创建交互式 Web 应用的库

  • numpy: 用于所有数值运算的库

  • pandas: 用于处理数据框的库

  • pydeck: 基于 Deck.gl 构建的可视化库,专门用于渲染大规模地理数据

  • openai: 提供对 GPT-3.5 和 GPT-4 等模型访问的 OpenAI Python 库,用于自然语言处理(NLP)任务。

  • RandomForestRegressor: 我们在应用中使用的 scikit-learn 模型

  • SentenceTransformer: 用于嵌入的库(参见上一章)

代理的代码相同,除了ItineraryPlannerAgent。为了获得更好的响应,我们在这里使用 OpenAI 的 GPT-4 模型:

class ItineraryPlannerAgent:
    def __init__(self, api_key):
        self.api_key = api_key
    def create_itinerary(self, destination, best_month, hotel, duration):
        client = openai.OpenAI(api_key=self.api_key)
        prompt = f"""
        Create a {duration}-day travel itinerary for {destination} in the best month: {best_month}.
        Recommended Hotel: {hotel['name']}.
        """
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are an expert travel planner."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=300
        )
        return response.choices[0].message.content

操作方式相同:它接受旅行目的地、最佳旅行时间、推荐酒店和旅行时长,随后生成一个结构化的行程。请注意,我们需要使用 API 密钥来验证对 OpenAI API 的请求。同样,代理所做的只是根据相同的输入生成行程:旅行地点、最佳旅行月份、酒店详情和旅行天数。GPT-4 也类似于 GPT-2:我们必须提供一个包含信息的提示,然后模型会自回归地生成旅行行程

在这里,我们提供与之前提供给系统相同的数据(你可以在存储库中找到它):

图 10.25 – 代码截图

图 10.25 – 代码截图

到目前为止,我们可以初始化我们的代理,每个代理都有自己的不同目的:

openai_api_key = st.secrets["general"]["openai_api_key"]
weather_agent = WeatherAnalysisAgent()
hotel_agent = HotelRecommenderAgent()
itinerary_agent = ItineraryPlannerAgent(api_key=openai_api_key)
weather_agent.train(historical_weather_data)
hotel_agent.add_hotels(hotels_database)
Your API should be in a file TOML, like this:
[general]
openai_api_key = "YOUR_API"

注意,openai_api_key = st.secrets["general"]["openai_api_key"]使用 Streamlit 的密钥管理器来安全地访问 OpenAI API 密钥。实际上,st.secrets是一种在 Streamlit 应用中存储和检索敏感凭证的方式。API 密钥存储在st.secrets["general"]["openai_api_key"]下,表示它被保存在secrets配置中的"general"部分内。st.secrets的目的在于防止敏感凭证在脚本中以硬编码的形式存储,从而降低隐私泄露的风险。

现在,让我们开始构建我们的界面:

st.title("AI Travel Planner ✈️")
st.write("Find the best time to travel and discover the perfect hotel!")
destination = st.text_input("Enter your destination (e.g., Rome):", "Rome")
preferences = st.text_area("Describe your ideal hotel:", "Luxury hotel in city center with spa.")
duration = st.slider("Trip duration (days):", 1, 14, 5)

首先,我们添加一个标题:st.title() 设置 Streamlit web 应用的标题。这个标题将显示在页面顶部。在这个阶段,我们使用 st.write() 提供对应用目的的简要说明。接下来,st.text_input() 用于创建一个用户可以输入目的地的框。请注意,我们提供了一个关于用户可以输入的内容的提示——“输入你的目的地(例如,罗马):”——并且有一个默认值“罗马”(如果用户没有输入任何内容,则默认为罗马)。st.text_area() 创建一个多行文本框,用户可以在其中描述他们理想的酒店。我们使用 text_area 允许用户提供详细的酒店偏好。st.slider() 创建一个滑块输入,用于选择旅行时长(有参数定义了最小时长为1天,最大为14天,默认时长为5天)。

图 10.26 – 应用中的输入偏好

图 10.26 – 应用中的输入偏好

在这一点上,我们将处理用户添加信息并按下按钮之后发生的事情。为了回顾,系统根据天气条件(通过使用历史数据和随机森林算法)预测最佳旅行月份,找到符合用户偏好的酒店(使用酒店数据和嵌入相似度),最后,使用 OpenAI 的 GPT-4 创建个性化行程。

我们已经创建了框架来可视化结果:最佳旅行月份、推荐酒店、AI 生成的行程,最后是目的地的地图可视化。所有这些只有在我们的用户按下按钮时才会发生,我们将在下一部分创建这个按钮:

if st.button("Generate Travel Plan ✨"):
    best_months = weather_agent.predict_best_time({'latitude': 41.9028, 'longitude': 12.4964})
    best_month = best_months[0]['month']
    recommended_hotels = hotel_agent.find_hotels(preferences)
    itinerary = itinerary_agent.create_itinerary(destination, best_month, recommended_hotels[0], duration)
    st.subheader("📆 Best Months to Visit")
    for m in best_months:
        st.write(f"Month {m['month']}: Score {m['score']:.2f}")
    st.subheader("🏨 Recommended Hotel")
    st.write(f"**{recommended_hotels[0]['name']}** - {recommended_hotels[0]['description']}")
    st.subheader("📜 Generated Itinerary")
    st.write(itinerary)
    # -------------------------------
    # Interactive Map
    # -------------------------------
    st.subheader("🗺 Destination Map")
    map_data = pd.DataFrame(
        {'lat': [41.9028], 'lon': [12.4964]},
    )
    st.map(map_data)

if st.button("生成旅行计划✨"): 创建了一个交互式按钮,标签为 best_months = weather_agent.predict_best_time({'latitude': 41.9028, 'longitude': 12.4964})。请注意,我们输入了罗马的目的地纬度(41.9028)和经度(12.4964),根据天气得分获得了最佳月份,并选择了最佳月份。在这个阶段,我们使用 hotel_agent.find_hotels(preferences) 根据用户的偏好确定最佳酒店。这个代理将返回一个与用户描述相匹配的酒店列表。

由于我们拥有所有详细信息,我们可以生成我们的行程。itinerary = itinerary_agent.create_itinerary(destination, best_month, recommended_hotels[0], duration) 正是如此操作;它接受之前定义的输入并生成一个结构化的 AI 生成的行程。一旦我们有了行程,我们就开始向用户展示它。我们使用 st.subheader("``📆 最佳访问月份") 创建一个子部分,然后遍历 best_months 并打印出每个月及其天气评分。在此阶段,我们在 st.subheader("``🏨 推荐酒店") 之后显示最佳酒店。最后,st.subheader("``📜 生成的行程") 允许我们在其中插入行程的子部分。在最后一部分,我们展示城市地图。

图 10.27 – 生成的输出(第一部分)

图 10.27 – 生成的输出(第一部分)

图 10.28 – 生成的输出(第二部分)

图 10.28 – 生成的输出(第二部分)

图 10.29 – 生成的输出(第三部分)

图 10.29 – 生成的输出(第三部分)

在本节中,我们创建了一个多智能体系统并将其嵌入到应用程序中。这样,即使是没有编程知识的用户也可以与我们的系统交互。用户可以通过点击一个简单的按钮来运行系统。

我们讨论了应用程序作为一个孤立系统;在下一节中,我们将看到模型不是一个孤立的概念,而是生态系统的一部分。必须考虑到这种复杂性,在下一节中,我们将讨论模型的生命周期,从构思到部署。

机器学习操作和 LLM 操作

我们已经看到了如何创建一个包含多智能体系统的应用程序。当我们用 Python 编写脚本时,我们创建了一个可以在我们的计算机上运行的元素,但这不是一个产品。将脚本转换成应用程序允许用户即使不知道如何编程也能与我们的应用程序交互。Streamlit 允许我们快速原型化我们的应用程序。这并不适合产品,尤其是当它要被多个用户使用时。在本节中,我们将讨论所有必要的操作,以使我们的模型作为一个产品运行。

机器学习操作(MLOps)是一套旨在简化和管理生产中机器学习模型生命周期的实践和工具。它结合了机器学习、DevOps 和数据工程实践,以确保机器学习系统的持续集成/持续交付(CI/CD)、监控和扩展。

图 10.30 – MLOps 组合

图 10.30 – MLOps 组合 (arxiv.org/pdf/2202.10169)

MLOps 在将模型转化为现实世界中有用的应用中发挥着关键作用。简而言之,MLOps 涵盖了在生产环境中模型的发展、监控和维护,使得从研究产品到功能产品的转变成为可能。以下是涉及的各个阶段:

  1. 模型开发:这是第一步,其中设计并训练了机器学习模型。通常,在这个阶段,数据科学家和数据工程师在模型选择、数据集以及训练和测试过程中进行合作。

  2. 测试:通常,测试阶段是模型开发的一部分;然而,今天,对模型的测试更加重视。因此,我们将其视为一个单独的阶段。实际上,特别是复杂模型可能会表现出意外的行为,因此测试通常被视为一个单独的阶段。

  3. 部署:一旦模型开发和测试完成,它可以在生产环境中部署。这一微妙的步骤要求模型与其他现有系统(先前已开发)集成,并且能够实时使用。

  4. 监控和维护:一旦模型部署,我们必须确保其性能不会下降,并防止运营问题。同时,我们可能需要更新模型或确保与新的系统元素兼容。

图 10.31 – MLOps 的高级流程视图 (https://arxiv.org/pdf/2202.10169)

图 10.31 – MLOps 的高级流程视图 (arxiv.org/pdf/2202.10169)

大型语言模型操作(LLMOps)是 MLOps 的一个扩展,专门关注 LLMs 的部署、维护和管理。它结合了 MLOps 的原则,但也解决了与大规模 NLP 模型工作相关的独特挑战和需求。

然而,LLMOps 增加了额外的复杂性。原因如下:

  • 模型大小和复杂性:在 MLOps 中,模型的大小和复杂性可能有所不同,但通常它们不需要像 LLMs 那样多的计算能力或内存。模型可能包括传统的机器学习算法、较小的深度学习模型或针对结构化数据的专用模型。LLMs 可能有数十亿个参数,因此需要优化的基础设施(通常涉及专门的硬件,如 GPU 或 TPU)或分布式训练。这意味着需要更多的专业知识和专用基础设施(专用硬件和存储),这可能非常昂贵。

  • 训练和微调:在 MLOps 中,训练要容易得多。许多模型体积较小,因此可以轻松重新训练。重新训练本身可以程序化进行。微调 LLMs 更复杂且资源密集。收集和处理 LLM 所需的数据集是资源密集型的。

  • 可扩展性和部署:在 MLOps 中,将模型部署到生产环境通常是直接的。另一方面,扩展 LLM 需要能够确保在高需求时提供必要支持的专用基础设施。实际上,当有大量用户时,延迟可能会显著增加。优化推理过程中的延迟可能是一个微妙的过程,可能会降低性能。

  • 监控和维护:在生产环境中监控 ML 模型涉及跟踪关键指标,如准确率、精确率和召回率,以及模型漂移或数据漂移。监控 LLM 不仅包括通常的性能指标,还包括文本生成的质量、用户反馈以及如偏见或有害输出等伦理问题。虽然从准确率的角度评估输出是直接的,但评估 LLM 是否产生幻觉或不适或有害的内容则更为复杂。一些偏见可能很微妙,但仍可能被用户注意到。

  • 模型治理和合规性:虽然治理和合规性在任何 ML 部署中都至关重要,但 MLOps 主要关注确保数据隐私和模型透明度,尤其是在处理敏感或受监管的数据时。对于 LLMOps,不仅涉及隐私问题,而且还可以用于生成涉及广泛主题的文本,存在生成不适当内容的风险。随着法规的发展,评估偏见、公平性和伦理问题既复杂又不断演变。

在执行 LLMOps 时,涉及到的附加复杂性可以通过以下例子来展示。如果我们想要从头开始训练一个模型,我们就需要检索至少包含 10 亿个标记的语料库。这些标记需要从不同的来源收集(如书籍、网站、文章、代码库等)。在 MLOps 中,我们通常在数据集已经存在的情况下创建模型(例如,通过用户与我们的网站互动)。为经典模型(图像或表格)预处理数据集的步骤比大型语料库(如去偏、消除重复等步骤)要简单得多。此外,由于我们的数据集可能超过数百个 TB,因此复杂性也更大。虽然我们可以轻松地训练一个 ML 模型(甚至是在消费级计算机上),但 LLM 则不再如此。特别是对于更大的模型,我们必须使用专用基础设施,并且无法进行许多实验(测试不同的超参数或不同的架构组合)。同样,微调将比重新训练我们的模型更受欢迎。

测试也不再依赖于简单的度量(如准确率),而是需要人工参与的评价。鉴于系统的语言中心特性,准确率这样的指标只能为我们提供关于模型输出的部分信息。只有人类(即使我们使用其他大型语言模型进行大规模检查)才能从创造力、偏见、质量和不适当内容的存在等方面评估大型语言模型的输出。此外,在预训练之后,通常有一个步骤会使用人类反馈来进一步提高模型的输出。此外,我们还必须继续评估我们的 LLM,因为流量可能会增长,或者我们的模型必须具备的语言和知识可能会发生变化。例如,用于医疗用途的 LLM 需要更新新的治疗方法。

在下一节中,我们将从开发像 LLM 这样复杂的模型所面临的复杂性开始。

模型开发

模型的开发始于语料库的收集。这种收集通常分为两种类型:通用数据和专用数据。通用数据代表网页、书籍和对话文本等数据。另一方面,专用数据是为特定任务设计的,例如多语言数据、科学数据和代码:

  • 通用数据:考虑到互联网上数据量巨大,现在数据收集通常从使用下载的页面数据集或进行爬取以收集新数据开始。此外,还有对话数据集(如 Reddit 或其他平台上的讨论)、与 LLM 的聊天和其他来源。书籍也是训练的另一个流行来源,因为它们通常包含关于不同主题的连贯、高质量的文本。这些数据集包含质量数据(如维基百科和博客文章)的混合,但也包含大量需要删除的数据,如垃圾邮件、有毒帖子等。

  • 专用文本数据:今天,向 LLM 添加多语言语料库以改善其语言能力是很常见的(例如,由于添加了多语言语料库,PaLM 覆盖了 122 种语言)。

    添加科学文本可以改善科学和推理任务的表现。今天存在大量可供使用的文章数据集,可以直接添加。几乎所有现代预训练数据集也插入代码。代码和其他结构化数据的添加似乎与某些推理任务性能的提高有关。

图 10.32 – 现有 LLM 预训练数据中各种数据源的比例( https://arxiv.org/pdf/2303.18223 )

图 10.32 – 现有 LLM 预训练数据中各种数据源的比例(arxiv.org/pdf/2303.18223)

数据收集完毕后,必须进行预处理以去除不必要的标记,如 HTML 标签或其他展示元素,减少文本变化,并消除重复数据。如今,我们尝试使用启发式算法或分类器消除低质量数据。例如,我们可以在维基百科等质量数据上训练一个分类器,以识别我们想要保留的内容。另一方面,启发式算法依赖于上游定义的一系列规则(如统计属性、关键词的存在或不存在等)。去重是一个重要的步骤,因为它会影响模型多样性和训练稳定性。通常,使用不同的粒度,如句子或文档级别,以避免重复的单词模式。此外,今天另一个常见的步骤是隐私降低,其中试图通过一系列上游定义的规则来移除个人身份信息(PII)。一旦进行这些步骤,就可以进行分词。分词被认为是一个关键步骤,因为它在很大程度上影响模型性能。字节对编码(BPE)分词通常是最广泛使用的方法之一。

图 10.33 – 预训练 LLMs 典型数据预处理流程的示意图(img/B21257_10_33.jpg)

图 10.33 – 预训练 LLMs 典型数据预处理流程的示意图(arxiv.org/pdf/2303.18223)

一旦我们预处理了语料库,我们就可以在下一阶段训练模型。为了训练模型,我们需要定义一个策略来安排之前引入的多源(如维基百科、互联网上的文本、书籍等不同类型的数据)。实际上,有两个重要方面被确定:每个数据源的比例(数据混合)以及每个数据源在训练中安排的顺序(数据课程)。由于每种类型的数据都会影响性能,数据必须按照精确的分布混合。这种分布可以是全局的或局部的(在特定的训练步骤)。为此,我们可以决定对各种来源进行上采样和下采样,以尊重我们决定的数据混合。例如,在 LLaMA 预训练的情况下,作者选择以下比例进行训练(基于实验结果,表明这个比例效果良好):80%网页,6.5%来自 GitHub 和 Stack Exchange 的与代码相关的数据,4.5%来自书籍,以及 2.5%来自 arXiv 的科研数据。这些值加起来并不正好是 100%,因为剩余的部分包括原始论文中未明确详细说明的其他一些小来源。如今,这个配方已被用于许多不同类型的 LLMs,而具有特定目的的 LLMs 则有不同的代码和科学文章的比例。

通常,异构语料库更受欢迎,因为多样性增强了模型跨领域的泛化能力。相比之下,过度同质的数据集可能会阻碍泛化。此外,数据呈现的顺序——通常被称为数据课程——至关重要。因此,训练数据通常组织起来,首先发展基础技能,然后是更专业的技能。

要做到这一点,你首先使用简单/通用的例子,然后添加更复杂或更具体的例子。例如,对于像CodeLLaMA-Python这样的代码特定模型,顺序如下:2T 通用标记,500B 代码密集型标记,以及 100BPython 密集型标记。

通常,创建允许我们收集和组织数据的管道非常重要。通常,这类管道被称为提取、转换、加载(ETL)管道。因此,如果我们想下载一组网页,我们需要创建一个 ETL 管道,使我们能够下载页面并将它们以及一组元数据加载到数据库中。这些元数据将用于数据清洗和数据调度。一旦数据下载完毕,就需要对其进行转换。因为我们的语料库包含不同类型的数据,所以为不同类型的数据预处理设置不同的管道是很好的(例如,从网页中删除 HTML 标签,从代码中删除注释等)。

此外,数据是一个重要的资源,必须控制访问。确实,我们需要防止数据泄露并确保我们的语料库符合如通用数据保护条例(GDPR)等规定。通常,还会实施基于角色的访问控制(RBAC),其中不同用户控制不同的数据语料库。例如,管理员或分析师可能拥有不同的权限,以避免数据污染或数据问题。

一旦我们有了数据并且已经清理了它,我们就创建特征(即用于训练的数据)。特征存储通常是优化以支持训练的数据库。想法是拥有一个专门的数据库,我们可以高效地用于训练。

图 10.34 – 持续训练的机器学习管道自动化( https://cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning )

图 10.34 – 持续训练的机器学习管道自动化(cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning)

模型训练

一旦我们确定了特征,我们需要决定我们的基础模型将是什么。有两种选择:使用已经训练好的 LLM 或者对已经训练好的模型进行微调。在前一种情况下,今天的大多数模型都是因果解码器(正如我们在第二章和第三章中看到的)。尽管结构仍然是基础,但现在有不同替代方案和修改(例如专家混合架构)以及修改注意力机制以增加上下文和减少计算成本。然而,从头开始训练一个 LLM 是非常昂贵的,因此大多数公司专注于使用预训练模型并进行微调。

因此,选择基础模型将是一项重要任务。首先,我们必须选择一个在输出质量方面具有所需性能的模型。显然,所选模型必须与我们可用的资源(硬件和成本)兼容。此外,我们可能希望选择在通用基准测试中表现较低但在其他方面表现优异的模型。例如,如果我们的应用侧重于拥有代码助手,那么拥有在编码基准测试中表现优异的 LLM(大型语言模型)比拥有更广泛能力的 LLM 更好。

在选择模型时,我们需要考虑到其大小会影响其内存占用和存储。更大的尺寸通常意味着更高的成本,尤其是如果我们使用云服务提供商。此外,并非所有模型都适用于所有应用(例如,我们不能使用大型模型针对特定设备)。此外,更大的模型也有更高的延迟(处理输入并产生输出的时间)。高延迟会破坏用户体验,并可能导致用户选择竞争对手。正如我们在第三章中看到的,目前存在一些技术(蒸馏、量化和剪枝)可以在保持性能的同时减少模型大小。另一个重要点是模型的许可。并非所有模型都有开源许可;一些模型可能在存储库中可用,但可能不可用于商业用途。

微调的目的是使模型能够获得特定的技能或某些特定的知识。在前一种情况下,它通常被称为指令微调。指令微调是监督训练过程的一个子类别,旨在使模型更能够遵循指令或为特定任务进行训练。在存储库中,通常有只是预训练或已经经过指令微调步骤的模型。如果我们希望模型获得一组特定的技能,那么收集用于指令微调的数据集可能对我们更有趣。再次提醒,以下是一些注意事项:

  • 数据分布:指令微调考虑了不同任务混合,因此我们的数据集应该遵循这一原则,并包含多个示例。理想情况下,这些示例应该涉及不同主题、不同上下文、不同长度、不同风格和不同类型的任务。

  • 数据集质量:通常,在这一步(质量检查)中,使用不仅在实际正确性方面正确,而且确保任务完成正确且解释充分的示例非常重要。例如,目前使用的是思维链示例,其中解释的是中间思考过程,而不是仅仅解决方案。这些示例是由人类生成的;然而,为了节省成本,最初可以使用较大的模型来创建指令微调的数据集。例如,一个 70 亿参数的模型可以用来准备调整 70 亿参数模型的数据集。

  • 复杂性:一般来说,我们希望我们的模型获得能力。通过简单的示例,模型将学习结构并获得对任务的总体理解。然而,数据集中也应该包含一些困难的示例,需要多步推理或本质上复杂。这些示例反映了现实世界问题的复杂性,并且已被证明有助于模型提高其推理技能。

  • 数量:与数量相关联的也有一个论点。根据一些研究,较大的模型可能需要更少的示例。例如,具有 700 亿参数的模型可能只需要 1000 个高质量的示例。相比之下,较小的模型可能需要更多的示例。较小的模型可能需要很多示例来理解任务,而要掌握它可能需要更多。一个 70 亿参数的模型可能需要多达一百万个示例。

构建包含数千个示例的数据集可能特别昂贵。在许多研究中,只有一小部分是由人类创建的。为了达到所需的示例数量,可以使用模型生成它们或整合现有的数据集。Hugging Face 包含许多用于指令微调的数据集,包括通用目的和特定领域的数据集。

图 10.35 – 构建指令微调数据集 (https://arxiv.org/pdf/2303.18223)

图 10.35 – 构建指令微调数据集 (arxiv.org/pdf/2303.18223)

这些数据集的构建,尤其是针对特定领域,也需要专家的参与(例如,如果数据集是针对金融或医学领域,与该领域或其它机构的专家合作是常见的)。与预训练数据集类似,这个数据集也将进行预处理。例如,低质量示例将被过滤掉(最常用的方法之一是有一个关键词列表,这些关键词表示不适当的内容、离题示例等),并且将使用长度(例如,对于模型来说太短或太长的示例)和格式(对于某些任务,示例以特定方式格式化,不符合格式的示例将被移除)过滤器。此数据集也将进行去重,过于相似的示例也经常被移除(如果你让一个大型语言模型生成示例,可能会发生生成过于相似示例的情况)。可以使用嵌入等模式进行这项任务,其中过滤掉相似度过高的示例。MinHash是减少任务计算成本的另一种流行选择。MinHash 生成模式的紧凑表示(向量的模式),然后通过相似度函数进行比较。

由于我们对特定任务的模型性能感兴趣,因此还会进行一个额外的步骤:数据净化。这是一个确保我们的指令微调数据集不包含与评估或测试集中相同或过于相似的示例的过程。实际上,一旦我们对模型进行了指令微调,我们希望在预留的测试集上对其进行测试。如果有过于相似的示例,我们就无法验证过拟合或存储现象。数据净化使用与数据去重类似的技术进行。

在进行实际训练之前,通常还会进行一个额外的步骤,即数据质量评估。数据集将根据质量、准确性、复杂性等几个标准进行评估。通常,会计算一些统计参数(如损失)并对一些示例进行人工检查。最近,使用LLM 作为评判者的策略越来越受欢迎,这是一种 LLM 评估某些示例质量的方法。在这种情况下,LLM 被提供一种模板,通过提供分数来检查示例的质量。或者,今天也有专门训练的模板来提供质量分数。例如,ArmoRM-Llama3-8B-v0.1等奖励模型被训练来生成一个输出,该输出代表文本的质量,从有用性、正确性、连贯性、复杂性和冗长性等方面来衡量。

模型测试

一旦我们有了我们的数据集,我们就可以进行微调。微调允许我们引导 LLM 的能力和知识。我们必须记住,微调不是灵丹妙药;它既有风险也有好处。例如,微调利用了模型预先存在的知识,但也为特定领域进行了重新聚焦。这可能导致性能下降和幻觉。因此,在第 5章到第 7章中,我们探讨了替代方案(RAG 和 GraphRAG)。在第 3章中,我们看到了现在也有像 LoRA 和 QLoRA 这样的高效微调技术,这使得整个过程成本大大降低。今天,不同的库可以对这些模型进行微调,例如由 Hugging Face 创建的 TRL 库、基于 Unsloth 的 Unsloth 和 Axolotl;这些库还具有其他功能。

训练之后,关键步骤是 LLM 评估。通常,评估分为三个阶段:

  • 在预训练期间:在这一步中,监控模型的训练,通常评估的指标包括训练损失(基于交叉熵的指标)、验证集上的损失、困惑度(训练损失的指数,最常用的指标之一)和梯度范数(指示训练中是否存在任何不稳定性)。

  • 在预训练之后:一旦预训练完成,就会在基准数据集上对能力进行分析。在这些数据集中,评估了模型的知识和解决某些问题的能力。例如,MMLU 测试了模型在大量领域上的知识,而像 HellaSwag 这样的数据集则测试了模型的推理技能。

  • 在微调之后:在指令微调之后,通常会对 LLM 的遵循指令、对话和使用工具等能力进行评估。由于微调允许您将模型适应特定领域,在这种情况下使用专门的基准是有益的。例如,对于医学知识,可以使用 Open Medical-LLM Leaderboard 这样的数据集,或者对于编码技能,BigCodeBench Leaderboard 是一个流行的选择。

图 10.36 – LLM 评估分类(img/B21257_10_36.jpg)

图 10.36 – LLM 评估分类(arxiv.org/pdf/2310.19736)

最后两个步骤(在预训练之后和在微调之后)也可以通过人工检查或使用 LLM 作为裁判来进行。例如,对于开放式文本生成,使用标准指标评估模型的能力更为困难。此外,在特定领域评估模型的能力需要更深入的分析。

如果我们的 LLM 是 RAG 等系统的一个组件,那么不仅应该评估 LLM 的能力,还应该评估整个系统。实际上,我们可以单独评估模型的推理或幻觉能力,但由于模型将成为系统的一部分,我们需要评估整个产品。例如,我们应该评估 RAG 系统在检索和响应生成方面的准确性。即使是对于 RAG,也有评估系统的指标和特定库。例如,RAGAS(检索增强生成评估)使用 LLM 来评估 RAG 响应。ARES(通过合成数据自动评估 RAG)是一个综合工具,它利用合成数据生成来评估模型质量。

推理优化

我们的 LLM 必须部署并消耗资源;我们的目标现在是将推理过程优化,以避免用户遇到延迟并减少我们的成本。基本上,推理过程中发生三个过程:

  1. 分词和嵌入:输入被转换为数值表示,然后转换为向量。

  2. 计算:为每个多头注意力计算一个键和一个值。

  3. 生成:输出是顺序产生的。

前两个步骤成本较高,但可以在 GPU 上轻松并行化。另一方面,第三个步骤是顺序的,因为每个输出标记都依赖于前一个标记。推理优化的目的是加快这三个步骤,在本小节中,我们将探讨一些技术。

模型推理优化

要生成一个标记输出,我们需要所有先前的上下文。例如,对于产生的第 15 个标记,我们应该计算所有标记(1 到 14)的 键值(KV)乘积。这使得整个过程非常缓慢,随着时间的推移,注意力的成本呈二次方增长(O(n²))。KV 缓存缓存并重用先前标记的键(K)和值(V)张量,从而允许更快地计算注意力分数。这减少了内存和计算成本,使得推理接近线性时间(O(n))。通常,这个过程是这样的:对于第一个标记,我们计算并存储 (K,V)。对于第二个标记,我们再次找到 (K,V) 并添加 K,V。换句话说,注意力只应用于新标记。正如我们在 第二章 中看到的,这是注意力的计算:

图 10.37 – 注意力计算

图 10.37 – 注意力计算

在 KV 缓存中,我们计算 KV 乘积,然后将乘积结果保存在内存中。在新的标记出现时,我们检索这条信息(KV 乘积),并只为该标记计算 KV 乘积。

图 10.38 – KV 缓存过程

图 10.38 – KV 缓存过程

KV 缓存通过消除一些冗余计算(它阻止我们重新处理序列的所有先前部分)来加速推理,与长上下文窗口具有良好的扩展性,并且现在已针对主要库和硬件进行了优化。当然,使用 KV 缓存意味着我们使用更多的内存。实际上,这意味着我们必须为每个标记、每个注意力头和每层保留每个 KV 缓存的内存。在实践中,这也限制了我们可以使用的上下文窗口的大小。显然,在模型训练期间,它几乎没有用处,因为我们必须进行参数更新。因此,今天,有一些方法试图压缩 KV 缓存,以减少内存成本。

用于加速推理的另一种技术是连续批处理。这种技术的主要目的是并行化各种查询,然后将模型内存成本分摊到批处理中,并将更多数据传输到 GPU。传统的批处理会导致输入处理速度变慢,并且不适合推理,因为各种查询的大小可能不同。相反,连续批处理允许动态处理多个用户请求,允许并行处理多个推理请求,即使它们在不同时间到达。不同时间到达的请求会动态地组合成一系列批次,而不是有一个固定的批次来填充。批处理引擎将多个用户的提示合并成一个批次。不需要等待整个批次,当资源可用时就会处理新的标记。这种技术也与 KV 缓存兼容;一些标记可能已经被处理,我们可以从内存中召回它们以进一步加快处理速度。连续批处理因此允许更低的延迟,允许同时为多个用户提供流式传输,并提高资源利用率。当然,它比标准的注意力实现更复杂,需要不同的实现:我们必须优化用户管理,并对 KV 缓存进行大量请求。

推测解码是自回归语言模型中用于加速文本生成的另一种优化技术。经典的 LLM 一次只生成一个标记,标记生成不可并行化,导致推理效率低下。在推测解码中,我们有两个模型协同工作:

  • 一个小型、快速的“草案”模型,生成多个候选标记

  • 主要的、更大的 LLM 用于验证候选者,并接受或纠正它们

草稿模型(与主模型具有相同 LLM 架构但参数更少的小模型)一次生成多个推测性标记。主 LLM 检查这些提议的标记;如果它们与较大 LLM 的输出匹配,则被接受。然而,如果没有匹配,LLM 将丢弃它们并继续生成。这个过程会迭代进行,直到输出完成。推测性解码使得减少推理中的顺序步骤数量、加快响应速度以及在不降低质量的情况下最大化 GPU 消耗成为可能。当然,草稿模型必须生成好的候选者;如果小模型不准确,我们将失去加速的优势,这意味着我们需要另一个模型。这种方法在长文本输出上比在小输出上效果更好。

加速推理的另一种方法是使用特定的注意力形式。分页注意力是一种优化内存管理技术,用于在 LLM 推理过程中高效地处理大型 KV 缓存。它通过动态管理内存分配和防止碎片化,像虚拟内存系统一样工作。它受到计算机内存系统管理的启发,而不是将 KV 缓存存储在连续的内存块中(这可能导致碎片化),而是将它们存储在较小的内存页中。这使得从 KV 缓存中更快地检索信息(以及仅必要的信息)成为可能。因此,分页注意力可以防止 GPU 内存碎片化,使系统在长上下文中更加高效(减少用户和系统之间长聊的内存消耗),并通过允许更容易地从 KV 缓存中获取信息来降低延迟。FlashAttention是另一种使推理过程更有效的方法,通过减少内存消耗来加快注意力的处理速度。它通过处理小块中间矩阵而不是存储大型中间矩阵来实现这一点。这样,它更有效地利用了 GPU 资源。在 FlashAttention 中,只有各种标记的小块存储在 RAM 中。如今,许多模型在训练期间使用旨在加快推理的注意力形式。多组注意力(MGA)是多头注意力(MHA)和稀疏注意力之间的混合。MGA 不是每个注意力头都关注所有标记,而是将多个头组合在一起以实现更有效的计算。在 MGA 中,头不是分开的,而是分组到特定的簇中,并处理一组字符。这使得降低计算成本成为可能,对于稀疏注意力形式更加灵活,并使加速训练和推理成为可能。另一种流行的替代方案是多头潜在注意力(MLA),它用于现代 LLM 中。在标准的 MHA 中,我们明确计算所有头的注意力。在 MLA 中,我们使用潜在的头,这些头间接编码标记之间的关系,而无需进行完整的成对注意力计算。通过这种方式,模型通过学习压缩表示来提高泛化能力,而不会牺牲准确性。这需要推理期间更少的注意力,并节省内存。

图 10.39 – 加速推理方法概述(img/B21257_10_39.jpg)

图 10.39 – 加速推理方法概述(arxiv.org/pdf/2407.18003)

这些技术,如图图 10**.39所示,展示了如何通过多个阶段——压缩、缓存和内存优化——提高推理效率。有了这个基础,我们现在可以探索这些优化如何在现实世界的部署场景中应用。

数据、管道和张量并行性

另一种使训练更有效的方法是并行化。对于神经网络,模型并行是将模型分布到多个设备(如 GPU 或 TPU)以克服内存和计算限制。虽然这可以用来加速训练,但在其他情况下,这是必要的,因为模型太大,无法适应单个设备。有几种方法可以并行化模型,我们将在下面看到:

  • 数据并行被认为是 simplest 的方法,其中模型的副本被分布到多个计算设备(例如,GPU、TPU 或甚至不同的机器)上,不同的训练数据集子集被输入到每个副本中。在训练过程中,对各种 GPU 的梯度进行平均;这用于模型更新。然后,每个模型在工人(GPU/TPU)之间进行复制,输入数据批次被分割成分配给不同工人的小批次。在正向传播过程中,每个工人计算其小批次的预测和损失。随后,每个工人为其分配的数据计算梯度。这些梯度可以通过平均或使用更复杂的方法进行聚合,聚合后的梯度用于更新所有模型副本,确保工人在同步。数据并行可以以多种方式实现,最常见的是同步数据并行,其中所有设备在同步之前计算梯度。一旦所有梯度都可用,就进行平均。尽管这种方法确保了一致性,但一个工人可能会减慢训练速度。为了克服这一点,我们有了异步数据并行,其中每个设备独立进行本地模型更新,这可能会引入过时的梯度(过时的更新)。还有一种中间方法(过时同步数据并行),其中工人在与其他人同步之前执行多个本地更新。数据并行也可以通过中央服务器集中化,或者通过各种工人在环形拓扑中交换梯度进行去中心化。数据并行允许将工作负载分配到不同的设备上,从而提高训练速度,当有多个设备时扩展良好,实现起来不复杂,并且效率高,因为模型保持在各种设备上,而不需要交换。另一方面,由于通信开销,梯度同步可能会很慢,尤其是如果通信效率不高。设备速度的变化,例如使用不同的硬件或 GPU 版本,可能会进一步加剧这个问题。此外,大批次大小可能会导致收敛问题,随着设备数量的增加,管理同步变得越来越复杂。

图 10.40 – 数据并行中随时间处理的迷你批次。每个 GPU 拥有所有层的副本(以不同颜色显示)以及不同编号的迷你批次由不同的 GPU 处理( https://arxiv.org/pdf/2111.04949 )

图 10.40 – 数据并行中随时间处理的迷你批次。每个 GPU 拥有所有层的副本(以不同颜色显示)以及不同编号的迷你批次由不同的 GPU 处理(arxiv.org/pdf/2111.04949)

  • 管道并行是一种分布式训练技术,其中深度学习模型的不同层被分配到不同的设备(例如,GPU 或 TPU),并且迷你批次通过管道顺序处理。这项技术有助于训练不适合单个设备内存的极大型模型。管道并行通常用于 GPT-3、GPT-4、LLaMA 和 DeepSeek 等转换器模型,其中模型大小超过了单个 GPU 的内存容量。模型被分成多个阶段,每个阶段代表连续层的子集,并分配给不同的 GPU。一个批次被分成迷你批次,而一个迷你批次被分成微批次。然后,一个微批次从第一阶段开始处理并传递到下一阶段。在第一个微批次完成所有阶段之前,第二个微批次就开始处理(一旦第一阶段清除,就可以开始处理第二个微批次,而第一个微批次不需要通过所有层,从而允许以高效的方式并行化处理)。反向传播遵循正向传播相同的管道,但顺序相反;梯度从最后阶段到第一阶段。一旦所有微批次都完成,就可以进行模型更新。

图 10.41 – 单个微批次的正向和反向更新(img/B21257_10_41.jpg)

图 10.41 – 单个微批次的正向和反向更新(arxiv.org/pdf/2403.03699v1)

图 10.42 – 并行处理两个微批次(img/B21257_10_42.jpg)

图 10.42 – 并行处理两个微批次(arxiv.org/pdf/2403.03699v1)

管道并行可以在不同的方式下进行,例如前向一次,后向一次(1F1B)调度,其中每个 GPU 同时进行一次前向传播和一次后向传播。或者,每个设备可以包含多个模型分区,从而进行更灵活的调度。管道并行允许训练不适合单个 GPU 的非常大的模型,允许更好地利用各种设备(每个设备持续处理微批),降低内存瓶颈的风险,并且非常适合 Transformer。另一方面,它是一个更复杂的系统,其中必须管理阶段,以确保其中一些阶段没有计算密集型层,从而成为瓶颈(仔细分层以平衡各种设备之间的工作负载)。在最初的迭代中,系统效率较低,因为它等待被微批填充(第一阶段在其它阶段之前开始工作),由于梯度聚合,通信更加复杂,并且在设计系统时增加了复杂性。

  • 张量并行是一种模型并行技术,其中模型中单个权重张量(矩阵)被分割到多个 GPU 上。与传统模型并行不同,后者将整个层分配到不同的 GPU 上,张量并行将单个层内的计算分解并分布到多个设备上。这种方法对于大规模的转换器模型特别有用,因为某些操作(如注意力层中的矩阵乘法)需要巨大的内存和计算能力。张量并行不是在单个 GPU 上计算和存储整个权重矩阵,而是将它们分割到多个 GPU 上。例如,一个全连接层将权重矩阵W应用于输入X以获得输出Y。如果W太大以至于无法在一个 GPU 上处理,我们可以将其分割到多个 GPU 上。然后每个 GPU 将只进行部分计算,产生部分输出,之后再将这些输出聚合。同样,在反向传播过程中,我们必须重新分配梯度计算,以便正确更新各种矩阵W的权重。列向张量并行是转换器中最广泛使用的一种,其中权重矩阵按列分割到多个 GPU 上,然后每个 GPU 计算部分输出,之后再将这些输出连接。考虑到模型的自我注意力机制,查询(Q)、键(K)和值(V)矩阵按列分割到多个 GPU 上。然后每个 GPU 计算部分注意力分数,随后将各种结果在 GPU 之间聚合以重建最终的输出。这种方法的优点是,不需要存储整个权重矩阵,每个 GPU 只存储一部分。此外,大型矩阵的乘法可以分布,从而加快计算速度,这使得它对于大型模型特别高效。另一方面,始终存在通信开销的风险(GPU 必须频繁交换部分结果,这可能会减慢训练速度),实现起来可能很复杂,并且除非是大型模型,否则不值得。

图 10.43 – 张量并行 (https://arxiv.org/pdf/2311.01635)

图 10.43 – 张量并行 (arxiv.org/pdf/2311.01635)

下表比较了张量并行、数据并行和流水线并行在内存使用、通信开销和复杂性等关键维度上的差异:

特性 张量并行 数据并行 流水线并行
如何工作 在 GPU 之间分割单个张量 在每个设备上复制完整模型;分割数据 在 GPU 之间分割模型层
内存使用 低(权重被分割) 高(完整模型存储在每个 GPU 上) 中等(层分布)
通信开销 高(频繁的跨 GPU 通信) 高(梯度同步) 中等(微批处理传递)
最佳适用 非常大的模型,具有巨大的权重矩阵 中等大小的模型,具有大量数据集 深度模型,如变换器
复杂性 高 低 中等

表 10.1 – 大规模模型训练中张量、数据和管道并行性的比较

混合并行性通过整合不同类型的并行性,试图优化跨多个 GPU 的训练。通常,可以将各种方法结合起来,尽管这需要更多的复杂性。例如,数据并行性确保 GPU 处理不同的批次,而模型并行性(张量或管道并行性)确保模型在多个 GPU 上得到优化。例如,如果模型太大,无法在一个 GPU 上运行,我们可以使用模型并行性并将模型分割到多个 GPU 上。然后我们可以使用 16 个 GPU 将数据批次分割到模型的 4 个副本中。

到目前为止,我们已经探讨了如何构建一个完全工作的 AI 驱动 Streamlit 应用程序,该应用程序集成了多个代理和外部 API,如 OpenAI。然而,当应用程序从开发阶段转移到生产阶段时,需要考虑一些重要的挑战。

生产环境中的错误处理

在本节中,我们将探讨我们可以采用的一些方法来处理当应用程序从开发阶段转移到生产阶段时可能遇到的问题。你可能会遇到的一些典型问题包括:

  • OpenAI API 暂时不可用

  • 间歇性网络故障或超过速率限制

  • 不完整或缺失的日志系统

让我们看看如何有效地缓解这些问题:

  • try/except 块。以下是如何在调用 OpenAI API 时处理不同类型错误的示例:

    try:
         response = client.chat.completions.create(
             model="gpt-4",
             messages=[...],
             timeout=10           # optional timeout
         )
         return response.choices[0].message.content
    except openai.RateLimitError:
         st.error("Rate limit exceeded. Please try again later.")
    except openai.APIError as e:
         st.error(f"OpenAI API error: {str(e)}")
    except Exception as e:
         st.error(f"Unexpected error: {str(e)}")
    
  • 临时问题:当出现间歇性网络故障或外部 API 暂时不可用时,应用程序不应立即失败,而是可以尝试操作几次:

    import time
     import random
    def call_openai_with_retry(prompt, retries=3):
         for i in range(retries):
             try:
                 return client.chat.completions.create(
                     model="gpt-4",
                     messages=[ {"role": "user", "content": prompt}]
                 )
            except openai.APIError:
                 wait = 2 ** i + random.random()
                 time.sleep(wait)
        st.error("Failed after multiple retries.")    return None
    
  • st.write() 对于快速调试来说很好,但在生产环境中,你需要一种更持久和结构化的方式来跟踪应用程序中发生的事情。

    基本的日志系统可以帮助你记录重要事件并捕获可能不在 UI 中出现的错误:

    import logging
     logging.basicConfig(level=logging.INFO)
     logger = logging.getLogger(__name__)
    try:
         logger.info("Calling OpenAI API")
         response = client.chat.completions.create(...)
    except Exception as e:
         logger.exception("API call failed")
         st.error("Something went wrong.")
    

生产环境的安全考虑

部署在生产环境中的应用程序通常涉及 API 密钥和可能敏感的用户数据,因此必须从一开始就仔细处理安全问题。

最基本的实践之一是避免将凭证(如 API 密钥)直接硬编码到源代码中。相反,应使用环境变量或专门的密钥管理系统安全地管理凭证。

生产环境中的安全通常涉及三个关键领域:

  • 管理密钥

  • 防止数据泄露

  • 保护你的部署环境

让我们讨论这些问题。

生产环境中的密钥管理

在生产环境中安全地管理密钥的两种常见方法:

  • st.secrets:这对于部署在 Streamlit Cloud 上的应用程序来说很理想

  • 使用环境变量:这适用于 Docker 容器或本地服务器部署

这两种方法都可以让你将敏感信息从源代码中排除出去,但正确的选择取决于你的部署环境。

这里为每种方法提供了一些示例:

  • st.secrets:当使用 Streamlit 时,创建一个.streamlit/secrets.toml文件,让你可以将其中的秘密定义到其中。以下是一个示例:

    [general]
     openai_api_key = "application-api-key"
    

    在你的代码中这样访问它:

    import openai
     openai.api_key = st.secrets["general"]["openai_api_key"]
    
  • 使用环境变量:对于 Docker 化或本地部署,建议将秘密作为环境变量存储,将它们与源代码分开。要使用环境变量,你必须在运行应用程序之前在终端或部署环境中定义它们。

    例如,在基于 Unix 的终端(Linux、macOS 或 WSL)中,你可以这样定义变量:

    export OPENAI_API_KEY="your-api-key"
    

    然后,在你的 Python 代码中,如下访问变量:

    import os
    openai.api_key = os.getenv("OPENAI_API_KEY")
    

    export命令只为当前终端会话设置环境变量。这意味着它只在你关闭终端时保持活动状态。要使用变量启动应用程序,你必须在该 shell 会话中运行它:

    export OPENAI_API_KEY="your-api-key"
     streamlit run app.py
    nano ~/.bashrc
    

    然后,保存并关闭它。从现在开始,每次从新的终端会话启动应用程序时,你的应用程序将自动找到 API 密钥。

防止数据泄露

在生产环境中,最容易被忽视的安全风险之一是通过日志记录、错误消息或配置错误的 URL 无意中泄露敏感数据。

虽然日志记录对于调试和可观察性至关重要,但如果在不适当的过滤下捕获了秘密、令牌或用户数据,它很容易变成一种负担。

以下是一些最佳实践,以最大限度地降低风险:

  • 避免记录秘密:即使在调试模式下,也永远不要将 API 密钥、访问令牌或密码打印到日志中。这适用于客户端和服务器端日志。

  • 清理用户数据:如果你的应用程序记录了包含用户提供的输入或错误跟踪的日志(例如,表单提交、头信息和有效负载),请确保对敏感字段(如电子邮件地址、信用卡号码或个人标识符)进行遮蔽或删除。

  • INFO、WARNING、ERROR或DEBUG)并限制生产环境中的调试级别日志。仅启用诊断问题所必需的内容,而不过度暴露内部信息。

  • 处理错误:避免直接向用户发送原始堆栈跟踪或系统错误消息。这些可能会泄露有关你的后端、框架或数据库的详细信息。

防止数据泄露是设计系统,假设秘密和用户数据必须始终受到保护,即使在边缘情况或故障中也是如此。

保护你的部署环境

即使你的代码避免了数据泄露并且你的秘密得到了适当的管理,如果你的应用程序运行的环境配置不当,它仍然可能存在漏洞。

例如,在现代工作流程中,容器化是打包和部署应用程序最常见的方式之一。实际上,容器提供了跨环境的可移植性和一致性,但它们也引入了特定的安全风险。

错误或较差的 Dockerfile 配置可能会引入多个漏洞,例如以下内容:

  • 如果镜像包含不必要的软件包或工具,则会增加对已知漏洞的暴露。

  • 如果秘密直接存储在镜像中,则可能发生凭证泄露

  • 如果容器以 root 用户运行,则可能发生权限提升

  • 如果卷没有被适当限制,则可能对主机资源进行不安全访问

为了减轻这些风险,遵循一系列容器安全最佳实践非常重要。让我们看看一些简单的指南,以使你的基于 Docker 的部署更加安全并准备好生产:

  • 使用python:3.11镜像而不是python:3.11-slim可能包含数十个不必要的系统工具。如果其中任何一个有已知的漏洞,它们就会成为意外的攻击,即使你的应用程序没有使用它们。

  • 将.env文件放入 Docker 镜像允许任何有权访问镜像的人提取并使用它们。

  • root用户和root权限,如果与 Python 依赖项中的漏洞利用相结合,这可能会使攻击者完全控制容器,甚至可能控制主机。

  • /:主机文件系统的根。授予对整个主机文件系统的完全访问权限,包括敏感的系统目录、用户数据和配置文件。

  • /etc:系统配置目录。包含关键配置文件,包括/etc/passwd、/etc/shadow、网络设置和用户权限。暴露这些文件可能允许操纵主机系统的行为。

  • /var/run/docker.sock:Docker 守护进程套接字。赋予容器对在主机上运行的 Docker 引擎的直接控制权。这允许容器启动、停止和管理其他容器,包括挂载卷和在主机上执行代码。

下面是一个最小化和安全的 Dockerfile 示例:

# Minimal python image
 FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
COPY . .
# Create and use a non-root user through the keyword USER
 RUN useradd -m appuser
 USER appuser
CMD ["streamlit", "run", "app.py"]

为了在运行时安全地注入秘密,请使用docker run传递的环境变量或使用如Docker secrets之类的秘密管理工具:

# Runtime execution
 docker run -e OPENAI_API_KEY="your-api-key" my-streamlit-app

MLOPs 和 LLMOPs 是任何希望在生产中使用 ML 模型或 LLM 的人的重要概念。在下一节中,我们将讨论生产部署中的其他重要概念,例如异步编程,它允许我们处理多个并发用户请求。

异步编程

到目前为止,你已经看到了任务依次执行示例。但如果某些任务在等待时不需要阻塞整个程序的流程呢?这就是异步编程发挥作用的地方。

异步编程允许任务协作共享 CPU。不是每个任务都等待前一个任务完成,任务可以自愿暂停并让其他任务运行,从而更好地利用单个处理器的时间。这并不表示同时执行;相反,它表示它们操作的智能交织;这在等待 I/O 操作等事物时特别有用。

想象一下,一个人在与多个人进行多个对话时切换,高效且礼貌。在 Python 中,这是通过使用asyncio模块实现的,该模块支持单个 CPU 上的协作多任务。

正如你在比较表中看到的,异步代码与使用线程或多个进程不同。它只在单个核心上运行,但仍然可以感觉很快,尤其是在处理许多 I/O-bound 任务时。

Python 模块 CPU 数量 任务切换风格 切换决策
asyncio 单一 协作多任务 任务通过await关键字自愿交出控制权
threading 单一 预先多任务 操作系统决定何时切换线程
multiprocessing 多个 预先多任务 独立运行的进程,但位于同一台机器上;操作系统决定何时切换

表 10.2 – Python 中的并发机制:asyncio、线程和进程之间的差异

并发在两种类型的场景中特别有用:当程序等待外部系统的响应(I/O-bound)时,以及当它处理高计算负载(CPU-bound)时。

在 I/O-bound 情况下,脚本的大部分时间都在等待从文件系统、网络连接、数据库或 API 等来源的数据到达。在这段时间里,CPU 通常处于空闲状态,这使得并行运行其他任务成为完美的机会。

相比之下,CPU-bound 任务使处理器完全忙于计算,如渲染图像、解析大型数据集或执行加密操作。在这些情况下,并发通过在多个 CPU 核心上分配工作负载,实现真正的并行执行。这种并发(更准确地说是并行)可以显著减少重计算的总处理时间。

任务类型 主要限制 示例 并发优势 执行风格
I/O-bound 慢速外部系统 读取文件、API 请求、数据库查询 在等待 I/O 时保持 CPU 忙碌 协作(asyncio)
CPU-bound 繁重计算 数据处理、图像处理、加密 在多个核心上分配负载以实现真正的并行性 预先(threading、multiprocessing)

表 10.3 – I/O-bound 与 CPU-bound:任务类型和最佳并发模型

以下图表说明了在处理 I/O-bound 操作时,同步和异步任务执行的不同之处。

图 10.44 – 阻塞与非阻塞 I/O 执行的比较

图 10.44 – 阻塞与非阻塞 I/O 执行的比较

在第一行,每个请求会阻塞 CPU 直到 I/O 完成。在第二行(异步),CPU 在 I/O 等待时间内在任务之间切换,提高单核效率并最小化空闲时间。

当多个 I/O 密集型请求按顺序到达时,使用单个线程逐个处理每个请求会在 I/O 等待时阻塞程序。

为了提高响应性,可以使用 threading 模块将每个请求委托给单独的线程。

在以下图中,每个进入的请求被分配给四个工作线程之一。实际的工作负载(T1, T2, T3, ...)代表短期的 CPU 活动与 I/O 等待的交错:

图 10.45 – 使用四个工作线程和交错 CPU/I/O 工作负载的并发请求处理

图 10.45 – 使用四个工作线程和交错 CPU/I/O 工作负载的并发请求处理

当你的程序在与慢速的外部系统(如 API、数据库、文件系统或甚至 GUI)交互时必须保持响应性时,这种模式很有用。

异步编程是一种并行编程类型,它允许程序在不阻塞主执行线程的情况下并发执行任务。例如,当有多个用户同时与系统交互时,我们将同时处理更多任务,其中一些任务由于阻塞我们的代理而需要更多时间。在传统的同步编程中,任务一个接一个地执行,每个任务必须等待前一个任务完成才能开始;任务按照它们被编写的顺序顺序执行。每个任务必须完全完成,下一个才开始,如果任务涉及等待,如文件 I/O 或网络操作,这可能会导致延迟。另一方面,异步编程允许可能阻塞执行的任务被并发启动和处理。程序不需要等待任务完成,可以继续执行其他任务,一旦准备就绪,再回到阻塞的任务。这种方法通过更好地利用系统资源,尤其是在涉及高延迟操作的场景中(如网络请求或数据库查询),提高了效率,使应用程序更加响应和高效。

讨论异步编程有一些关键概念:

  • 并发性:这指的是同时处理不同任务的能力;然而,这并不意味着任务会同时处理。任务是在重叠的时间段内启动和完成的,但不是同时。

  • 并行性:这指的是同时完成任务的能力,通常是通过使用多个处理器或核心来实现的。虽然并发性可能涉及或不涉及并行性,但并行性总是涉及并发性。

  • 阻塞操作:这些是在开始新操作之前等待任务完成的操作(例如,在开始处理文本之前从磁盘读取文件)。

  • 非阻塞操作:这指的是启动一个任务并继续程序执行其他任务,而无需等待该任务完成的能力(例如,在等待 HTTP 请求响应的同时,使用大型语言模型生成更多文本)。

  • 回调:这些是作为参数传递给其他函数的函数,在任务完成时执行。

  • 承诺和未来:这些是表示异步操作最终结果的抽象。承诺是一个值(或结果),在那时可能不可用,但将在稍后的某个时刻可用。未来与承诺相同,但在 Python 和 Java 等语言中更常用。

  • 事件循环:这是异步程序的基本组件,其中任务、事件或信号被列出并安排在资源可用时执行。换句话说,我们使用事件循环来允许任务在没有阻塞主程序的情况下运行。事件循环等待事件发生,并在此时调用适当的回调函数。

  • 协程:这些是可以在执行过程中暂停和恢复的特殊函数。换句话说,一个函数可以开始,然后暂停以等待另一个任务的结果。例如,当我们开始分析某些文档时,函数会暂停,以便我们进行 HTTP 请求以找到完成函数所需的信息。当 HTTP 请求的结果到达时,函数会继续执行。

异步编程如何使代码执行更快可能看起来有些反直觉(毕竟,没有使用额外的资源)。我为了简洁和清晰在这里做了大量的修改。请确认你的意图是否得到了保留。在同步格式中,她在开始下一轮游戏之前,会先完成每一轮游戏。每次移动需要她 10 秒,而对手需要 60 秒,每位玩家 30 步(总共 60 步)的完整游戏需要 2,100 秒。连续玩 24 场比赛需要 50,400 秒,即大约 14 小时。

相比之下,异步格式中,Judit 在棋盘之间移动,每轮游戏移动一次,而对手在她轮换时思考。一整轮 24 步需要 240 秒,由于每位玩家响应需要 60 秒,Judit 在对手准备好的时候回到每个棋盘。在 30 轮比赛中,整个会话仅持续 7,200 秒,即大约 2 小时——这使得异步游戏在时间效率上显著更高。

在异步编程中,我们做的是完全相同的,事件循环允许我们以最优的时间管理方式管理各种任务。当需要运行其他任务时,一个可能会阻塞其他任务的功能可以被最优地阻塞,从而优化整个程序的管理。在这里,我们不想优化每场比赛的时间,而是整个表演的时间。

我们可以以不同的方式同时管理多个进程:

  • 多个进程:进程是执行中的独立程序。每个进程都有自己的内存、资源和执行上下文。以最简单的方式,我们可以同时管理不同的进程(例如,几个玩家同时玩 24 游戏是性能期间同时发生多个进程的简单例子)。在编程的情况下,这意味着不同的脚本或进程可以同时运行(例如,四个函数,每个函数在不同的 CPU 上运行)。然而,这种方法非常低效。

  • 多个线程:这是先前方法的变体。线程是进程内的最小执行单元。多个线程可以位于同一进程内并共享相同的内存,但每个线程都有自己的执行栈。在这种情况下,同时执行多个线程。

  • asyncio 通过利用协程和未来来简化异步代码,正是这样做的。

因此,异步编程在有些任务耗时且可能阻塞程序执行时可以提高性能。这样,系统可以在等待它们完成的同时继续执行其他任务。它还允许更好地利用系统资源(例如,在等待网络请求时,程序可以进行计算或处理其他请求)。异步编程还有助于实现更可扩展的系统,可以并行处理多个请求,减少线程数量。

asyncio

async/await 语法。它提供了一个运行异步操作的框架,而不依赖于多线程或多进程。asyncio 的核心是事件循环,它在后台调度和执行异步任务(称为协程)。协程在 Python 中类似于生成器:它可以暂停执行,让其他任务运行,然后稍后继续。事件循环跟踪这些协程及其结果的状态,这些结果以 futures 的形式呈现。

下面是一个协程的基本示例:

import asyncio
async def my_coroutine():
    print("Hello, world!")
# Create an event loop and run the coroutine
asyncio.run(my_coroutine())

虽然这段代码展示了如何通过事件循环定义和运行协程,但它还没有利用并发执行。事实上,为了并发执行多个异步任务,我们可以使用 asyncio.gather() 或 asyncio.create_task()。

虽然gather()在你想要运行多个协程并等待它们全部完成时很有用,但create_task()提供了更多的灵活性。它允许你在后台启动协程,并在你的程序中决定何时(或是否)等待它们的结果。让我们一起来查看一些示例。

以下示例使用asyncio.gather()来并发执行多个协程:

async def task1():
    await asyncio.sleep(2)
    print("Task 1 completed!")
async def task2():
    await asyncio.sleep(1)
    print("Task 2 completed!")
async def main():
    await asyncio.gather(task1(), task2())  # Run both tasks concurrently
asyncio.run(main())

在这种情况下,两个任务都是并发执行的,总执行时间将接近 2 秒:最长任务的执行时间。

我们可以使用asyncio.create_task()达到相同的结果,它提供了对任务调度的更多控制。与将协程分组并一起等待所有协程的asyncio.gather()不同,create_task()允许我们单独启动协程,并决定何时等待它们的结果。这在我们需要在执行其他工作的同时运行后台任务时特别有用。

下面是使用create_task()重写的相同示例:

import asyncio
async def task1():
    await asyncio.sleep(2)
    print("Task 1 completed!")
async def task2():
    await asyncio.sleep(1)
    print("Task 2 completed!")
async def main():
    t1 = asyncio.create_task(task1())
    t2 = asyncio.create_task(task2())
    # Both tasks start running in the background immediately
    await t1
    await t2
asyncio.run(main())

每次调用create_task()都会返回一个Task对象,它代表正在运行的协程,可以被等待、取消或监控。

结果是相同的:两个任务都是并发运行的,每个任务完成时都会打印输出。然而,使用create_task(),我们获得了更多的灵活性。

例如,我们可以启动几个后台任务,并在main()中继续执行其他逻辑。然后,我们可以在工作流程的特定点等待我们需要的仅有的结果。这种灵活性使得create_task()在复杂的工作流程中特别有用,在这些工作流程中,并非所有任务都同等重要或时间敏感。

为了更好地理解异步编程在现实世界中的影响,让我们比较一下同步与异步执行的示例。具体来说,我们将通过使用 Python requests库模拟从网站获取数据来使用 HTTP 请求。这将突出异步代码在处理 I/O 密集型任务(如网络调用)时如何显著提高性能。

下面是同步代码:

import requests
import time
def fetch_url(url):
    response = requests.get(url)
    return f"Fetched {url}"
def sync_fetch():
    urls = ['https://httpbin.org/get'] * 5  # Simulating 5 requests to the same URL
    results = [fetch_url(url) for url in urls]
    for result in results:
        print(result)
def main():
    start_time = time.time()
    sync_fetch()
    end_time = time.time()
    print(f"Synchronous version took {end_time - start_time:.4f} seconds")
# Run the synchronous example
main()

下面是异步代码:

import asyncio
import aiohttp
import time
async def fetch_url(session, url):
    async with session.get(url) as response:
        await response.text()  # Simulate processing the response
        return f"Fetched {url}"
async def async_fetch():
    urls = ['https://httpbin.org/get'] * 5  # Simulating 5 requests to the same URL
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for result in results:
            print(result)
async def main():
    start_time = time.time()
    await async_fetch()
    end_time = time.time()
    print(f"Asynchronous version took {end_time - start_time:.4f} seconds")
# Directly calling the asynchronous function in Jupyter
await main()

以下图示展示了上述所述的同步和异步实现的输出,分别。如图所示,同步版本依次执行 HTTP 请求,导致总执行时间更长。另一方面,异步版本并发发送所有请求,显著减少了所需的总时间。

图 10.46 – 同步结果

图 10.46 – 同步结果

图 10.47 – 异步结果

图 10.47 – 异步结果

异步编程与机器学习

在 Python 中将异步编程与机器学习(ML)结合可以是一种强大的组合。异步编程可以通过允许非阻塞操作来提高性能,例如加载大型数据集、运行超参数调整或与 API 交互。例如,我们可以看到不同的可能性:

  • 数据加载:在机器学习工作流程中,尤其是在处理大型数据集时,加载数据和预处理数据往往是一个瓶颈。异步编程可以通过并发加载数据的不同部分来加速这个过程。例如,您可以在同时执行一些 I/O 密集型任务(如数据增强、清理或转换)的同时异步加载数据集的多个块。

  • 超参数调整:超参数调整是耗时最长且速度最慢的过程之一,可以从异步执行一些任务中受益。例如,当对超参数进行网格或随机搜索时,可以同时评估不同的配置,而不是按顺序进行。

  • 异步推理:您可以使用异步编程创建一个非阻塞 API 来服务训练好的机器学习模型。这在部署模型进行实时推理并希望同时处理多个查询时特别有用。

  • 模型训练:尽管训练通常是在不同的 GPU/CPUs 上并行进行的,但异步调度可以结合使用,以在训练并行进行的同时更好地加载数据和预处理数据。这在我们需要检索不同数据时特别有用。

我们可以观察到超参数调整的经典示例。在这个使用经典 Iris 数据集和简单模型的简单例子中,我们将展示如何使用asyncio节省一些时间。

下面是同步代码:

import time
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
def train_and_evaluate_model(n_estimators, max_depth, min_samples_split, min_samples_leaf):
    # Load dataset
    data = load_iris()
    X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2, random_state=42)
        # Initialize and train the model
    model = RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        min_samples_split=min_samples_split,
        min_samples_leaf=min_samples_leaf
    )
    model.fit(X_train, y_train)
     # Evaluate the model
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
        return (n_estimators, max_depth, min_samples_split, min_samples_leaf, accuracy)
def tune_hyperparameters():
    n_estimators_values = [10, 50, 100, 150, 200]  # Hyperparameter values to tune
    max_depth_values = [5, 10, None]
    min_samples_split_values = [2, 5]
    min_samples_leaf_values = [1, 2, 4]
    results = []
    for n_estimators in n_estimators_values:
        for max_depth in max_depth_values:
            for min_samples_split in min_samples_split_values:
                for min_samples_leaf in min_samples_leaf_values:
                    results.append(train_and_evaluate_model(n_estimators, max_depth, min_samples_split, min_samples_leaf))
        # Find the best hyperparameters and accuracy
    best_params = max(results, key=lambda x: x[4])
    print(f"Best hyperparameters: {best_params[:4]} with accuracy: {best_params[4]:.4f}")
# Measure time for synchronous execution
start_time = time.time()
tune_hyperparameters()
end_time = time.time()
print(f"Synchronous version took {end_time - start_time:.4f} seconds")

在前面的脚本中,我们运行了一个机器学习模型并搜索最佳参数。这个脚本展示了即使是小型模型也需要花费很多时间来执行。

图 10.48 – 同步结果

图 10.48 – 同步结果

下面是异步代码:

import asyncio
import time
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
async def train_and_evaluate_model(n_estimators, max_depth, min_samples_split, min_samples_leaf):
    # Load dataset
    data = load_iris()
    X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2, random_state=42)
    # Initialize and train the model
    model = RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        min_samples_split=min_samples_split,
        min_samples_leaf=min_samples_leaf
    )
    model.fit(X_train, y_train)
    # Evaluate the model
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
    return (n_estimators, max_depth, min_samples_split, min_samples_leaf, accuracy)
async def tune_hyperparameters():
    n_estimators_values = [10, 50, 100, 150, 200]  # Hyperparameter values to tune
    max_depth_values = [5, 10, None]
    min_samples_split_values = [2, 5]
    min_samples_leaf_values = [1, 2, 4]
    tasks = []
    for n_estimators in n_estimators_values:
        for max_depth in max_depth_values:
            for min_samples_split in min_samples_split_values:
                for min_samples_leaf in min_samples_leaf_values:
                    tasks.append(train_and_evaluate_model(n_estimators, max_depth, min_samples_split, min_samples_leaf))
        results = await asyncio.gather(*tasks)
        # Find the best hyperparameters and accuracy
    best_params = max(results, key=lambda x: x[4])
    print(f"Best hyperparameters: {best_params[:4]} with accuracy: {best_params[4]:.4f}")
# Measure time for asynchronous execution
start_time = time.time()
await tune_hyperparameters()
end_time = time.time()
print(f"Asynchronous version took {end_time - start_time:.4f} seconds")

在这种情况下,我们使用异步编程训练了相同的模型。这种方法使我们能够节省时间,从而减少执行时间。

图 10.49 – 异步结果

图 10.49 – 异步结果

这也可以应用于作为代理的 LLM。传统上,函数调用会阻塞 LLM 推理,使得过程效率低下,因为每个函数调用必须完成才能进行下一个。一些作者提出,即使是在代理工具连接的情况下,也可以为 LLM(或生成令牌和执行函数调用)实现异步方法。例如,可以考虑可中断的 LLM 解码,其中函数执行器异步地通知 LLM,允许它在等待函数调用结果的同时继续生成令牌。这种方法的目的是通过重叠函数执行和令牌生成来减少延迟。

图 10.50 – 同步与异步函数调用(img/B21257_10_50.jpg)

图 10.50 – 同步与异步函数调用(arxiv.org/pdf/2412.07017)

因此,从理论上讲,我们可以为 LLM 代理采用三种方法:

  • 同步 LLM 函数调用:每个函数依次执行。LLM 必须等待每个函数完成,才能继续执行下一个。这种方法是最简单的,但它会增加系统的延迟,因为它必须等待每个操作完成(例如,读取 HTML、读取 XLS 文件、生成令牌等)才能继续。这导致效率低下,尤其是在有多个函数或某些函数花费大量时间的情况下。

  • 同步 LLM 函数调用与并行优化:这个过程试图并行优化每个任务(例如,同时读取 HTML、读取 XLS 和读取文本),但每个任务仍然会阻塞下一个任务。与之前的方法相比,优势在于每个函数可以并发执行,速度比之前的方法有所提高。需要同步以正确顺序执行任务。尽管任务已优化,但它们仍然是同步的,因此我们必须等待一个函数完成才能完成某些任务。

  • 异步 LLM 函数调用:在这种方法中,任务异步执行,意味着函数不会相互阻塞。系统可以在同时执行其他操作(如总结或保存数据)的同时读取 HTML、读取 XLS 和读取文本。这导致延迟显著改善,提高了资源利用率。系统确保在必要数据(例如,读取文本)可用后,才执行依赖任务(例如,总结和保存 PDF)。依赖关系动态管理,而不会停止其他操作。多进程并行化(先前的方案)创建不同的进程或线程以并发处理任务,从而分配资源和内存。这导致比异步版本更多的资源消耗,并且消耗量会根据我们拥有的函数数量而爆炸式增长。此外,这种方法更具可扩展性。图 10.51 – LLM 执行器交互比较 (https://arxiv.org/pdf/2412.07017)

图 10.51 – LLM 执行器交互比较(arxiv.org/pdf/2412.07017)

一旦我们使我们的系统(我们的应用程序)高效,它应该被放置在隔离的环境中,以避免外部问题。在下一节中,我们将详细解释 Docker 如何使我们能够做到这一点。

Docker

Docker是一个开源平台,它使开发人员和系统管理员能够在容器中创建、部署和运行应用程序。容器允许软件及其所有依赖项(如库、配置等)打包在一起,并在不同的环境中一致运行,无论是开发人员的笔记本电脑、测试服务器还是生产机器。

容器可以被视为虚拟机,从而减少开销,更好地利用资源和系统本身(尤其是如果我们需要在多个系统上使用单个模型时)。其理念是,我们的软件(其中我们的模型或一个 LLM 加上代理是一个组件)可以独立运行,以防止出现影响其执行和性能的问题。虚拟机的使用是系统如何在客户操作系统(OS)中运行并使用资源的例子。然而,为虚拟机优化系统需要相当多的资源。容器试图减少资源消耗和开销,以便运行应用程序。容器提供了一种打包应用程序的方法,使其从运行环境抽象出来。这种解耦使得容器可以在任何目标环境中运行,可预测且与其他应用程序隔离。同时,容器提供了以细粒度控制我们环境的能力。Docker 容器轻量级且便携,确保应用程序在任何地方的行为都相同。鉴于这些好处,许多公司已经采用了 Docker 容器。

Docker 基于几个主要概念:

  • 容器:这些是 Docker 的基本单元,包含一个应用程序及其依赖项的单个包,可以在不同环境中轻松移动。容器还包含操作系统内核,以减少所需资源。与包含整个操作系统的虚拟机不同,Docker 容器只包含运行应用程序所需的信息。这使得 Docker 容器运行得更快、更高效。

  • 镜像:镜像是一个只读模板,用于创建容器。它包含应用程序代码、运行时、库和环境变量。Docker 镜像包含应用程序的蓝图——所有能够执行代码所需的信息。Docker Hub 中有许多现成的镜像,可以用来高效地创建容器,并减少从头开始的需求。

  • Docker Engine:这是负责管理和运行容器(Docker 的运行环境)的组件。Docker Engine 在 Linux 和 Windows 操作系统上运行。

  • Dockerfile:Dockerfile 是一个包含构建 Docker 镜像指令的脚本。此文件指定了要使用的基础镜像、如何安装依赖项、环境配置和其他细节。

  • Docker Compose:这是一个用于定义和运行多容器 Docker 应用程序的工具。

Docker 容器因此具有许多优势:

  • 可移植性:Docker 容器将应用程序及其依赖项封装在一个单一、可移植的单元中。通过这种方式,系统抽象了环境之间的差异,使得部署更加可靠和一致。

  • 效率:与传统的虚拟机相比,该系统更加高效。通过仅使用内核,系统使用 fewer 资源,因此更容易部署和扩展。Docker 与 Kubernetes 和 Docker Swarm 等其他编排工具集成良好,这使得水平扩展(更多容器)和垂直扩展(增加容器可用的资源)应用程序变得更加容易。

  • 隔离:Docker 在容器之间提供了强大的隔离,允许它们独立运行,不会相互干扰,从而提高安全性并避免不同应用程序之间的冲突。

  • 版本控制和可重复性:容器允许你存储、共享和部署应用程序的特定版本,确保在不同环境中使用的是单个版本,从而提高可重复性。

就像任何系统一样,也存在一些缺点:

  • 安全担忧:它可能会引入一些漏洞,尤其是如果你不熟悉且不擅长使用 Docker。它有一定的学习曲线,尤其是如果你想高效地使用系统的话。

  • 数据管理:容器的设计是短暂的,这意味着如果容器被销毁,容器内的任何数据都将丢失。尽管有解决这个问题的方案,但它比传统系统需要更多的复杂性。

  • 复杂性:Docker 使得部署和管理单个容器变得容易;在许多节点上跨大量容器进行扩展和编排可能会变得复杂。Docker 的网络模型虽然灵活,但设置和管理可能很困难,尤其是当容器分布在多个主机上时。此外,如果有多个容器和相关工具,复杂性会增加。还有,操作系统内核有限,使得调试和实现某些功能变得更加复杂。

虽然 Docker 容器提供了许多优势,如便携性、效率、隔离性和可伸缩性,但它们也带来了挑战,尤其是与安全、复杂性和数据管理相关。

有时,我们的系统可能特别复杂,并且有多个容器;在以下小节中,我们将讨论 Kubernetes,它允许我们编排多个容器。

Kubernetes

Kubernetes是一个开源的容器编排平台,它自动化了容器化应用程序的部署、扩展、管理和操作。它在生产环境中管理和编排容器。

在 Kubernetes 中,Pod 是一组一个或多个相互关联并共享资源(如网络和存储)的容器。Pod 中的容器总是一起部署并共享相同的环境。服务是一种抽象,它定义了一组 Pod 的逻辑集合以及访问它们的策略。服务允许我们管理 Pod 如何在内部连接或对外部世界(在生产部署期间)开放。另一方面,节点是一个运行 Kubernetes 集群中容器的物理或虚拟机。集群中的每个节点至少运行一个 kubelet(运行容器的代理)和一个 kube-proxy(用于管理容器之间通信的网络代理)。节点的一组被称为集群,集群是提供 CPU、内存和存储等资源给应用的 Kubernetes 环境的骨干。Kubernetes 简化了容器的部署和维护,允许更容易地扩展和生成应用。它还允许我们更好地管理敏感数据配置以及一般的数据管理。

Kubernetes 被广泛用于部署、管理和扩展基于微服务的应用。它也是 DevOps 实践中的一种流行选择,因为它能够自动化部署并扩展应用。

Docker 与机器学习

多年来,Docker 在机器学习模型方面得到了广泛的应用,无论是用于运行模型还是用于基于机器学习的创作。它允许你设置一个准备好编码的工作空间,其中所有需要的依赖项都得到管理,从而加快了使用模型的过程。Docker 还允许提高模型的复现性,无论是训练还是推理。

图 10.52 – 使用 Docker 进行基于机器学习的软件项目目的概述 (https://arxiv.org/pdf/2206.00699)

图 10.52 – 使用 Docker 进行基于机器学习的软件项目目的概述 (arxiv.org/pdf/2206.00699)

Docker 可以与任何机器学习(ML)应用一起使用,包括使用大型语言模型(LLMs)和代理。例如,Ollama 在 Docker Hub 上提供了自己的 Docker 镜像,这使得创建使用 LLMs 的应用变得容易,并且可以直接部署到服务器上。我们的应用也可以包含 RAG 或其他组件。

此外,由于 Docker 容器现在被用于各种应用程序,而大型语言模型(LLM)被用于生成代码,因此 LLM 可以用于解决软件开发中环境配置的挑战,尤其是在使用 Docker 进行容器化时。事实上,许多软件仓库需要特定的依赖项才能正常运行,正确设置环境可能会出错、耗时且对用户来说困难重重。Docker 允许过程更加稳健和可重复,但 Dockerfile 必须手动配置,当项目有多个依赖项或配置涉及需要按特定顺序执行的多步操作时,可能会变得复杂。因此,有人提出使用 LLM 作为智能代理,理解仓库的依赖项和需求,并能够生成在 Docker 容器中工作的完全自动化的配置。Repo2Run 是一种利用 LLM 作为代理来控制过程并确保在部署前环境得到正确配置的方法。

Repo2Run 自动生成 Dockerfile,用于配置 Docker 容器。Dockerfile 包含设置 Docker 容器环境的指令集,包括安装依赖项和设置必要的配置。系统检查给定的 Python 仓库,检测其依赖项(例如,来自 requirements.txt 或 Pipfile 等文件),然后制定一个 Dockerfile 来重新创建必要的环境。Repo2Run 的核心创新在于其使用 LLM 驱动配置过程。LLM 智能地理解仓库的结构及其依赖项,减少了手动干预的需求。它自动化了传统上繁琐且容易出错的步骤,例如依赖项解析和配置设置。

图 10.53 – Repo2Run 的示例过程

图 10.53 – Repo2Run 的示例过程(www.arxiv.org/pdf/2502.13681)

将 Docker 容器迁移到 Kubernetes 需要一组配置文件,这些文件描述了应用程序如何在 Kubernetes 集群(Kubernetes 清单)中运行。这种迁移可能很复杂,尤其是对于包含多个容器和服务的应用程序。执行此过程可能会出错,耗时且难以管理,尤其是对于缺乏深入 Kubernetes 专业知识的小组。因此,一些研究(如 Ueno,2024)建议使用大型语言模型(LLM)来协助此过程并生成清单。

LLMSecConfig框架旨在解决容器化应用程序和容器编排器(COs)如 Kubernetes 的安全中的关键问题。CO 工具用于管理容器化应用程序的部署、扩展和网络。然而,由于它们的复杂性,许多可能的配置错误可能会暴露安全漏洞。例如,配置错误的访问控制、不恰当的资源限制或不安全的网络策略可能会使应用程序容易受到攻击。

这些配置错误很常见,因为该过程需要高水平的专业知识和手动操作。静态分析工具(SATs)通过分析容器化应用程序的配置文件,如 Kubernetes YAML 文件或 Dockerfile,来检测配置错误。尽管 SATs 是检测漏洞的好方法,但它们缺乏自动化,需要手动操作。LLMSecConfig 提出使用 RAG 和 LLM 从外部来源查找相关信息以识别配置错误。目标是将过程自动化,在这个过程中,同时识别和修复漏洞,同时保持操作容器的正常运行。

图 10.54 – LLMSecConfig 框架的自动化 Kubernetes 安全配置架构概述(img/B21257_10_54.jpg)

图 10.54 – LLMSecConfig 框架的自动化 Kubernetes 安全配置架构概述(arxiv.org/pdf/2502.02009)

这些方法表明,不仅 Docker 可以用于 LLM 应用,相反,LLM 也可以用来增强容器使用,尤其是在应用程序进入生产阶段时。

摘要

本章重点介绍了我们规划多代理系统的一个重要方面。无论我们的系统采取何种形式,它最终都必须进入生产阶段并供用户使用。用户的使用体验对我们心中的任何项目都至关重要。这就是为什么我们首先使用 Streamlit,这是一个允许我们快速实验并获得初步概念验证的框架。能够获得我们系统的原型使我们能够在投入大量资源进行扩展之前,了解其优势和劣势。Streamlit 的优势在于它允许我们分析后端和前端,使我们能够像用户一样与应用程序互动。Streamlit 允许我们在进行扩展和系统优化之前测试一个完整产品可能的样子。

显然,一个应用必须通过这个原型阶段才能进入生产。这一步要求我们对我们应用进行扩展。LLMs 是复杂的产物,需要大量资源,因此在本章的后半部分,我们处理了所有那些使训练成为可能以及之后发生的事情的操作。尽管我们主要关注 LLMs,但我们看到的一切都可以用于任何 ML 应用。

在本书的下一章和最后一章中,我们将讨论一个不断发展的领域的视角。我们将讨论一些重要的开放性问题,以及这个令人兴奋的代理领域为我们带来的未来机会和发展。

进一步阅读

第十一章:前方的未来

在这本书中,我们首先介绍了神经网络如何处理文本。正如我们所见,神经网络本身并不具备这种能力,但需要处理文本。简单的神经网络可以用于一些基本任务,如分类,但人类语言承载着大量的复杂信息。

在第二章和第三章中,我们看到了为了使用语义和句法信息,我们需要复杂的模型。Transformer 和 LLMs 的出现使得拥有能够推理和存储大量事实知识的模型成为可能。这些多功能知识和技能使得 LLMs 能够解决他们未经训练的任务(如编码、解决数学问题等)。尽管如此,LLMs 仍然存在一些问题,如缺乏专业领域知识、持续学习、能够使用工具等。因此,从第四章开始,我们描述了扩展 LLMs 能力并旨在解决 LLMs 问题的系统。

在本章中,我们将讨论一些问题尚未解决,以及未来将面临什么。我们将首先介绍代理在不同行业中的应用以及代理带来的革命。然后,我们将讨论一些在技术和伦理方面都十分紧迫的问题。

在本章中,我们将涵盖以下主题:

  • 人工智能代理在医疗保健领域

  • 人工智能代理在其他领域

  • 挑战和开放性问题

人工智能代理在医疗保健领域

人工智能发展中最令人兴奋的前景之一是拥有能够自行进行科学发现的自主系统。这种新范式被称为“人工智能科学家”。在这本书的整个过程中,我们看到了一些被认为符合这一理念的系统示例(ChemCrow、虚拟实验室等)。在本节中,我们将更详细地讨论这一范式:研究将走向何方,面临的挑战以及未来的发展。

人工智能代理背后的理念是利用我们迄今为止所看到的 LLMs(大型语言模型)与工具(代理)的结合。在未来,研究人员希望向这些系统添加一个实验平台(一个能够自行进行实验的自主系统),以便它们能够独立进行实验。这样,就可以通过一系列可执行的任务来接近生物学的复杂性,其中 LLM 可以将问题分解成一系列子任务并自主解决它们。目标将是不仅更快,而且更有效地实现发现。这样,人工智能科学家就能够以人类无法达到的速度和规模产生研究成果。

在第一阶段,人类将是项目的中心。科学家将为 LLMs 提供输入和批评,并将这些反馈纳入到过程中。在这个过程中,模型将分析问题,在人类监督下(或使用手工提示来引导其通过过程)搜索互联网上的信息,并制定计划。在这种场景中,LLM 将是人类的助手,它提出解决方案和假设。最终目标是有望实现一个自主代理。

这个愿景是几十年来生物医学研究持续过程的结晶。事实上,自 20 世纪 90 年代初以来,人们一直在谈论一种新的范式:数据驱动模型的运用。这种范式转变是由于技术进步和数据的广泛可用性所引起的。生物医学研究产生了大量数据,在过去的三十年里,这些信息已经开始集中存储在一系列数据库中。随着这种整合和信息的新可访问性,研究人员开发出各种工具。最初,这些计算工具是模型和统计方法,但逐渐,生物医学研究也从机器学习和 AI 模型中受益。从某种意义上说,一个领域的成功推动了另一个领域的成功,反之亦然。数据越集中,对社区的可访问性越高,就越能促进新模型的开发。通过新模型和方法获得的新发现促使新的实验和新数据的产生。例如,转录组实验允许产生大型数据集,这对于开发新的机器学习模型和工具是完美的。这些模型允许回答一些生物学问题,而这些答案又导致了新的实验和新数据的产生。AlphaFold2 之所以成为可能,仅仅是因为蛋白质数据银行(PDB)上数百万的结构。AlphaFold2 允许研究人员提出新的假设,这些假设后来通过 PDB 上的新实验和新结构得到了证实。此外,AlphaFold2 的局限性促使研究人员为特定问题收集新的数据。这些新数据和实验验证导致了新模型的出现,形成了正反馈。

如您所见,当大型语言模型(LLMs)出现时,已经存在进一步革命肥沃的土壤。首先,大量数据(数百万篇文章和庞大的实验数据库)可用,从而允许模型在这份数据上进行训练,或者能够通过专用数据库搜索信息。例如,一个模型可以通过专用 API 搜索它在生物序列中遗漏的信息。或者,一个 LLM 可以使用 RAG 搜索关于新文章的信息。其次,社区产生了数千个模型来解决特定任务。LLM 不需要知道如何解决一个任务;有一个经过精选的资源列表,它可以用于一系列子任务。因此,LLM 不需要额外的训练,只需知道如何协调这些特定的任务工具和模型。到这一点,我们已经拥有了创建代理系统所需的一切。代理可以在生物医学研究过程的每个步骤中找到,从而在更短的时间内促进药物开发,并节省重要资源。

图 11.1 – 利用 AI 代理赋能生物医学研究 (https://www.cell.com/cell/fulltext/S0092-8674(24)01070-5)

图 11.1 – 利用 AI 代理赋能生物医学研究 (www.cell.com/cell/fulltext/S0092-8674(24)01070-5)

生物医学 AI 代理

ChemCrow 是这类代理的一个例子,它针对特定的案例和领域进行了定义。该系统的推理仅限于特定任务;代理必须使用实验数据和现有知识。假设和任务都是由研究人员定义的;系统只需完成它们。第 1 级可以在人类监督下被视为协调者。

例如,ChemCrow 在研究自动化方面已经取得了具体的成果:根据发表在 自然机器智能 上的研究,ChemCrow 自动规划和执行了昆虫驱避剂和三种有机催化剂的合成,并指导了新型发色团(自然机器智能,2024)的筛选和合成。此外,通过整合 18 个专业工具,ChemCrow 简化了复杂的化学研究流程,显著提高了专家和非专家用户的工作效率和可及性(科学日报,2024)。

大多数代理方法都是基于使用一个中心 LLM。LLM 经过预训练,具有一般知识,然后与人类偏好对齐,以充分利用其知识和在预训练期间学习到的技能。生物医学领域需要专业知识和技能。因此,经常进行各种实验,其中 LLM 被微调以专门从事医学(例如,BioGPT、NYUTron 和 MedPalm)。这种方法显然成本高昂,并且模型很快就会过时(每天有数千篇论文发表)。因此,寻求不同的方法,在这些方法中不需要进行重复的微调。

一种选择是尝试使用一个模型(一个 LLM),但具有不同的专业领域(在每一轮分配一个特定的角色)。想法是使用一个模型,但设计提示来分配 LLM 的角色(生物学家、临床医生、化学家等)。还有其他替代方案,例如,使用指令微调来创建一个特定领域的专家(因此,与其将模型与特定知识对齐,不如将其与专家会执行的具体任务对齐)。例如,我们可以要求模型执行一个任务(为具有功能 Y 的蛋白质 X 编写一个序列)或提供特定的角色(你是专门研究蛋白质组学的生物学家;你的任务是:为具有功能 Y 的蛋白质 X 编写一个序列)。一个复杂任务可以由多个专家完成;例如,我们可以直接向模型提供任务(识别与呼吸道细胞相互作用的新冠病毒基因;设计抗体来阻断它)或将它分解成几个后续任务(第一个任务具有第一个角色,例如你是具有 Covid19 病毒专业知识的专业病毒学家;你的任务是:识别与呼吸道细胞相互作用的新冠病毒基因,然后分配模型第二个任务:你是具有设计阻断抗体专业知识的计算免疫学家;你的任务是:设计抗体来阻断它)。与之前的学习方法相比,这种方法(解决任务)不会像领域知识那样迅速过时。其他作者建议,人们可以简单地使用上下文学习。

这种策略意味着在上下文中向模型提供一系列所需的信息,以便扮演专家的角色(关于模型将要模仿的角色具体信息:定义、技能、特定知识等)。这种策略与通过提示分配角色的方法非常相似,但我们提供了更多的信息。尽管这些提示充满了信息和指令,但模型并不总是遵循它们。此外,在提示中描述专家的角色也很困难。因此,我们采取的另一种策略是模型独立生成和细化角色提示。

因此,智能体可能具有不同的工具和不同的目的。这种多角色方法的理由是,大型语言模型对规划和推理没有深入的理解,但仍然显示出获得的能力。因此,而不是一个智能体必须处理整个流程,我们有一个智能体池,其中每个智能体必须负责一个有限的子任务。通常,除了定义不同类型的智能体外,还需要定义工作协议(例如,在虚拟实验室中,除了智能体外,还定义了团队和个人会议的协议)。

在任何情况下,尽管人们对一个大型语言模型与几个人一起工作的多智能体方法抱有很大期望,但一些研究给出了混合的结果。事实上,一些作者表示,形式上称为“角色”(为大型语言模型分配角色)的东西并不提供特定的优势,除非在罕见的情况下。无论如何,到目前为止,有必要精确设计这些提示以使其有效(这是一个费时且反复试验的过程)。

由于大型语言模型具有良好的批判性思维能力,因此有人建议它们可以用于头脑风暴。尽管大型语言模型没有推理技能和有限的创造力,但它们可以快速浏览文献。然后可以使用智能体提出想法、评估最佳方案、细化并优先排序、提供批判性意见以及讨论可行性。一个有趣的可能性是使用一个智能体池,其中每个智能体具有不同的专业知识,这模仿了头脑风暴讨论过程。

可以创建不同的框架,其中智能体可以与人类或其他智能体进行交互。例如,利用批判能力可以促进具有不同目标的智能体的创建,以促进辩论。一组智能体可能专注于批判和挑战观点,而另一组可能旨在说服并为其观点辩护。每个智能体可能具有不同的专业知识和可用的不同工具。因此,这种方法从不同的角度评估研究命题。然后可以将研究想法视为一个优化问题,其中智能体试图找到最佳解决方案。除了智能体竞争的设置外,还可以利用合作的可能性。智能体可以对一个命题进行顺序反馈,目的是改进一个想法。这两个框架不一定是对立的,但可以在每个想法都经过反馈循环和批判的系统中进行调和。由于框架是用自然语言提示组织的,因此多智能体系统提供了独特的灵活性。

同样,并非所有代理都必须是平等的伙伴;可以组织层级结构。例如,一个代理可能扮演促进讨论或拥有更大决策权的作用。在虚拟实验室中,有一个代理扮演主要研究员的角色,负责发起讨论并拥有决策权。因此,可以建立多个决策层级,这些层级由复杂的架构管理。

注意,代理可以设计实验,并且结合经验工具,这些实验可以完成。这将提供一个新的能力水平,使整个过程成为端到端。

在这方面,高(www.cell.com/cell/fulltext/S0092-8674(24)01070-5)为生物医学研究中的代理系统定义了三个自主级别:

  • 级别 0:机器学习模型被研究者用作工具。研究者定义假设,使用模型完成特定任务,并评估输出。级别 0 系统是诸如在生物领域进行预测的模型之类的工具。

  • 级别 1:这也可以定义为 AI 代理作为研究助理;研究者定义假设,指定需要执行以达成目标的任务,代理使用一组受限的工具。ChemCrow 是这种类型代理的一个例子,它针对特定案例和领域进行定义。系统的推理局限于特定任务;代理必须使用实验数据和现有知识。定义假设和任务的是研究者;系统只需完成它们。级别 1 可以被认为是人类监督下的协调者。

  • 级别 2:也称为 AI 代理作为合作者,系统帮助研究者重新定义假设,部分得益于其庞大的工具集。尽管它对假设有所贡献,但其理解科学现象和生成创新假设的能力仍然有限。与 级别 1 区别开来的是,它参与假设改进和任务定义以测试它们。

  • 级别 3:这是最后一个级别,定义为 AI 代理作为科学家。在这种情况下,代理必须能够发展和外推新的假设,并定义无法仅从文献中推断出的发现之间的联系。一个 级别 3 代理随后可以与研究者平等合作,或者可以自行提出假设,定义测试假设的任务,并完成它们。

到目前为止,我们没有超越第 1 级的代理,我们可能需要为第 2 级和第 3 级开发新的架构和训练系统。第 0 级是一组研究人员使用的工具,但缺乏任何自主性。一个第 1 级代理可以编写代码进行生物信息学分析以处理数据,进行统计分析或使用其他工具。一个第 1 级代理使用第 0 级工具来完成这些任务,从而允许它测试一个假设。一个第 2 级代理不应仅仅执行人类指示的狭窄任务,而应该能够在给定初始假设的情况下对其进行细化、做出决定并自主执行任务。我们预计,在给出假设后,第 2 级代理还能够细化实验,并批判性地评估以最大化目标。另一方面,第 3 级代理应与人类合作生成假设,实际上可以被视为其同伴。第 3 级代理应能够评估现有挑战并预测未来的研究方向。此外,第 3 级代理应与实验平台集成,以便能够从头到尾执行整个过程。

其他领域的 AI 代理

在本节中,我们将讨论 LLM 代理如何以及将在各个行业中产生和产生全球影响。

物理代理

物理 AI 代理(例如,机器人)是能够导航现实世界并执行动作的 LLM 代理。因此,它们可以被视为将 AI 与物理世界结合在一起的具身系统。这些系统中的 LLM 为推理和上下文理解提供基础。在此基础上,可以添加其他模块,如记忆、额外技能和工具。

图 11.2 – 基于 LLM 的代理 (https://arxiv.org/pdf/2501.08944v1)

图 11.2 – 基于 LLM 的代理 (arxiv.org/pdf/2501.08944v1)

与虚拟代理不同,物理 AI 代理还必须理解和适应物理动态,如重力、摩擦和惯性。能够理解物理定律使其能够导航环境并执行任务。

使用 LLM 作为物理代理有几个优点:

  • 人机交互:LLM 允许人们通过自然语言的使用更轻松地互动。此外,LLM 的使用促进了更好的沟通和情绪管理,使得接受度更高。同样,人们已经习惯了与 LLM 协作,因此用户更容易与机器人协作解决问题、生成计划并执行任务。

  • 灵活性和适应性:今天的 LLM 具有多功能和通用能力,这使得它们更容易适应不同的任务和环境。此外,对于特定任务和环境,LLM 可以被微调以获取在不同环境中操作所需的新技能和知识。LLM 还具有推理能力和查找信息的能力;在预训练期间获得的知识和技能可以用来解决它们未被编程的任务。此外,LLM 可以通过自然语言被引导执行任务,这使得向机器人解释它们需要完成的任务变得容易。

  • 多模态能力:如今,多个大型语言模型(LLM)能够接受不同类型的模态作为输入。这种能力使它们能够整合来自不同类型传感器的信息,从而理解它们所处的环境。

近年来,将 LLM 与机器人结合的想法已经被探索。例如,PaLM-SayCan 是一个实验,其中他们使用 Google PaLM 来控制机器人。后来,谷歌使用了 PaLM-E 模型,它本身就是一个多模态模型。此外,今天正在测试新的替代方案,其中使用强化学习(RL)来改善 LLM 与环境的交互。

目前,由 LLM 控制的机器人仍存在一些挑战:

  • 数据集和训练:LLM 需要使用大量数据进行广泛的训练。收集这些数据集并不容易;迄今为止,还没有用于在环境中训练机器人的高质量数据集(需要大量图像和文本的数据集)。机器人必须通过任务描述和执行方式来训练,这使得获取这些多模态数据集变得昂贵。使用 RL 需要你获取有关系统采取的行动和环境影响的数据库。用于一个任务的数据集可能对另一个任务的训练没有用。例如,用于训练狗机器人的数据集不能用于训练类人机器人)。机器人训练需要与环境的交互;这是一个费时费力的过程。人们正在努力通过游戏和模拟来克服这个问题。然而,这种替代方案是对真实环境的简化,可能不足以满足需求。

  • 机器人的结构:机器人可以是任意形状。今天,运动机器人被设计成人类形状,但这并不是严格必要的。实际上,特定应用的机器人可能会有不同的形状。例如,如果一个机器人被设计成厨师,那么如果它被设计成适应其特定环境,它可能会有一个更好的形状。

  • LLM 的部署:在这些系统中,最佳方案是将 LLM 放置在机器人内部。将 LLM 部署在机器人内部是当前 LLM 的一个限制。许多 LLM 需要相当多的硬件资源(单个 LLM 需要不同的 GPU),这使得在本地大脑中部署 LLM 不可行。相比之下,今天,机器人的大脑位于云端。这显然有几个限制,尤其是在信号丢失的情况下。

  • 安全性:LLM 由于预训练而产生的偏差和误解。此外,LLM 也可能产生幻觉或犯错误。这些因素在执行任务时可能导致错误。一个能够控制物理动作的 LLM 可能会造成伤害。例如,机器人可能在烹饪时烧毁房屋。同时,LLM 也可能被黑客攻击,存在私人数据泄露或故意破坏的风险。

图 11.3 – 实体智能的挑战(img/B21257_11_03.jpg)

图 11.3 – 实体智能的挑战(arxiv.org/pdf/2311.07226)

游戏中的 LLM 代理

基于 LLM 的 AI 代理在游戏领域是另一个有趣的领域,其中模型的推理能力被用来与环境(游戏)交互。一般来说,一个专门用于游戏的框架需要一套组件,如 LLM、内存以及与游戏交互的工具。通常,系统使用 RL(其中游戏是一个场景)进行训练。然后,LLM 可以分析之前游戏中进行的动作,并推理出最佳行动。

图 11.4 – 基于 LLM 的游戏整体框架(img/B21257_11_04.jpg)

图 11.4 – 基于 LLM 的游戏整体框架(arxiv.org/pdf/2404.02039)

尤其是今天,许多游戏相当复杂,与环境和其他角色有复杂的交互。LLM 可以据此推理文本信息的丰富性(对象描述、任务描述、与角色的对话等),以决定行动计划或策略。例如,在宝可梦战斗中,每个玩家都有几个不同种类的宝可梦。每种种类都有不同的能力和统计数据;了解游戏知识是赢得战斗的必要条件。使用 LLM 可以让你利用模型的隐含知识来选择有效的策略(例如,使用电攻击对地面类型的宝可梦不会造成伤害)。此外,LLM 可以利用如思维链(CoT)等技术将不同元素整合到行动选择中(特别是如果它需要提前几步思考)。

图 11.5 – 使用语义知识制定有效策略(img/B21257_11_05.jpg)

图 11.5 – 利用语义知识制定有效策略 (arxiv.org/pdf/2404.02039)

基于 LLM 的代理对游戏来说是一个有趣的展望,因为它们可以丰富玩家的体验。例如,LLM 可以创建与玩家更自然交流的角色,在游戏过程中提供提示,与他们合作,并引导他们完成冒险。或者,它们可以用来生成更复杂且与玩家水平相匹配的对手。

网络代理

网络代理是专门设计用来与网络交互并协助人类完成繁琐和重复性任务的 AI 代理。因此,这些代理的目的在于自动化这些任务,提高生产力和效率。再次强调,大脑是一个 LLM,它允许进行推理和任务理解。网络代理的架构与本书中看到的类似。网络代理包含一个专门用于感知(来自网络的输入)、推理(LLM)以及一个专门用于与网络交互的模块。感知模块需要通过 HTML(读取并处理 HTML 文档的基于文本的代理)或通过网站截图(使用多模态 LLM)与网络进行交互。一旦 LLM 接收到一个任务,它就可以浏览网络、安排子任务、从记忆中检索信息,并执行计划。

图 11.6 – 网络代理框架 (https://arxiv.org/pdf/2503.23350)

图 11.6 – 网络代理框架 (arxiv.org/pdf/2503.23350)

AI 代理是 AI 的一个新前沿,它有望迅速产生实际影响。尽管它们具有潜力,但仍然存在一些挑战和问题,我们将在下一节中讨论。

挑战和开放性问题

在本节中,我们将讨论关于代理和 LLM 能力的一些开放性问题。尽管该领域取得了进展,但仍有几个问题需要解决,以确保 AI 代理的安全使用。

人机通信的挑战

一旦它们在现实世界中部署,代理可以执行可能导致问题性失败的行为。例如,购物代理可能会意外地花费金钱或无意中泄露敏感信息。编码代理可能会执行或产生病毒,删除重要文件,或将充满错误的代码库推入生产。与用户的沟通是避免此类问题的关键。代理的使用应基于两个关键原则:透明度和控制。确实,用户的目标和代理的行为之间必须保持一致;用户必须能够控制过程并访问其进度。人类与代理之间的沟通使我们能够推进这两个原则,但仍然存在一些开放性的挑战。

现代代理还不够完美,可能会犯错(尤其是对于复杂或包含多个步骤的目标)。因此,我们能够验证代理的行为,包括其工作结果以及它是否理解了任务,这一点非常重要。因此,必须找到一种方法来验证代理是否真正理解了目标,以及其计划和行动是否针对这个目标。验证代理真正理解了目标可以让我们避免代价高昂的错误,并节省计算和时间。

此外,LLMs 有一个随机组件。这个组件源于模型输出函数的概率性质(随机解码)以及任务执行过程中可能出现的复杂交互性质(意外事件)。因此,模型的结果和行为可能不一致。即使在确定性设置(温度 0)中,任务执行期间环境的变化可能会导致意外或不希望的结果。不一致性也可能来自 LLM 中过时的模型知识或存在的不完美的世界模型。例如,由于代理对现实世界的知识不匹配,它可能会购买超出预算或不符合用户需求的物品。

类似地,与用户和外部世界的交互会产生大量信息。这个广泛的背景对于指导代理的行为非常重要,这些行为随后可以从过去的交互中学习。尽管这个背景对于有效地执行任务至关重要,但它可能会随着时间的推移变得过于宽泛且难以管理。同时,现代大型语言模型存在噪声问题,当相关信息散布在不必要的细节中时,它们很难找到相关信息。因此,必须找到有效的方法,使代理能够专注于与用户最后一次交互的相关部分。此外,一些信息不应能够被重复使用(隐私和伦理问题),因此需要找到一种简单的方法来管理、编辑和删除过去的信息。

我们所讨论的是用户代理通信的一般挑战。我们还可以定义用户与代理之间以及反之亦然的开放挑战。首先,我们需要确保我们可以设计出通过解决这些点来使用户能够有效沟通的代理:

  • 明确的目标获取:系统的重点是让代理理解目标,并让用户能够清楚地提供目标。为了避免代价高昂的错误,我们需要设计用户可以明确定义目标的代理。一些可能性已经在某些领域进行了研究:逻辑规则集和形式语言的使用。为了使这项技术对每个人都是可用的,我们需要使用自然语言。自然语言在细微差别和歧义性方面都很丰富,它允许使用模糊和不完整的定义来定义复杂的目标。因此,必须定义机制来消除不明确的目标或允许代理从上下文(或过去的交互)中推断。

  • 尊重用户偏好:可以通过多种路径实现目标,但其中一些比其他路径更优(既有效率,也尊重用户的偏好)。用户的偏好可能与 LLM 的价值观不一致(在训练后,模型与人类偏好一致,但这并不一定反映普通用户的偏好,而只是反映了一组选定的注释者的偏好)。例如,如果用户请求一条路线,他们可能更喜欢更环保的交通工具。代理应尽可能遵守这些偏好,或者在无法遵守时中断流程以通知用户。模型对齐可能是一种考虑用户偏好的可能方法。然而,当前的对齐方法主要考虑的是总体偏好,而满足个人偏好的方法尚未开发。更普遍地说,代理也可以通过产生伤害(即使是以无意的方式)来实现目标,而且如果它有能力使用工具,这种风险就更大。

  • 整合反馈:我们知道代理容易出错,虽然我们可以制定策略来减少错误,但完全消除它们可能是不可能的。代理可能会在重复的交互中继续使用次优工具(不理解目标或设置错误的计划),从而让用户感到沮丧。纠正这种行为的一种方法是从用户那里获取反馈。现在有关于如何整合这种反馈以及如何以更有效的方式向代理表示这种反馈的研究(例如,将其转换为一级逻辑)。

与代理与用户沟通的方式相关的一些挑战也存在,特别是关于他们的能力、他们采取或将要采取的行动、目标实现和意外事件:

  • 代理的能力:用户必须能够理解代理的全部能力(和限制)才能进行明智的决策。应该清楚代理可以访问哪些信息,它将如何使用这些信息,它如何可以修改外部环境,它可以使用哪些工具,以及它是否可以连接到互联网。

  • 代理将采取哪些行动:为了解决目标,代理可以详细制定一个复杂的计划,这可能特别昂贵(时间、资源或金钱),并且可能违反一些用户的偏好。然后,用户应该了解代理采取的行动,并能够提供反馈。当然,必须找到一种有效的沟通形式,以避免传达无关紧要的细节,并确保用户完全理解代理的行动。此外,还应明确是否有些行动需要用户的明确批准。

  • 监控进度:对于一个在动态环境中移动的代理,完成任务的计划需要几个步骤;对于用户来说,了解代理正在做什么以及是否需要修改过程或停止它是很有用的。同时执行多个行动的代理可能导致意外和有害的行为。例如,一个构建新闻报告并在市场上进行投资的代理可能会阅读虚假新闻并执行一系列不良投资。

  • 环境和副作用的变化:代理必须监控环境的变化或其操作可能产生的潜在副作用。例如,一个被分配以最低价格在线购买产品的代理可能会在网上找到具有非常具有竞争力的价格的产品并下单。然而,该报价可能需要订阅或其他隐藏费用,这会使购买比用户的偏好或预算高得多。用户必须意识到代理行为产生的副作用。

  • 目标达成:用户指定一个目标,代理规划行动并执行它们。在这个过程中,用户必须清楚代理是否实现了目标(或部分实现)。因此,需要一种方法来评估目标是否已经实现。例如,目标可能是以某种性能类型购买最便宜的移动电话。代理可以引导购买,但我们还需要评估代理是否满足其他条件。因此,我们需要一种方法来验证目标是否已经完全且令人满意地实现。

与代理的沟通是一个复杂但关键的话题。沟通不畅可能导致系统故障,这是需要考虑的重要问题。在本节中,我们提供了一份从不同角度评估用户-代理沟通的重要元素列表。在下一小节中,我们将看到使用多代理是否比单代理更优越。一些研究对此观点提出了质疑。

多代理没有明显的优势

如前所述,基于 LLM 的代理可以被识别为一个具有初始状态(通常是在提示中指定其初始状态的描述),可以跟踪其产出(状态),并且可以通过使用工具与环境交互(动作)。多代理系统(MAS)被定义为一系列以协调方式相互交互以解决任务的代理。

MASs 是单代理系统的扩展,旨在创建一个更复杂的框架,能够解决复杂问题。显然,这意味着更高的计算成本(推理中更多的 LLM 调用)。这种更高的计算成本应该通过显著的性能提升来证明。事实上,一些研究表明情况并非如此。与单代理系统相比,MASs 在性能上仅提供微小的提升。

概述单代理和多代理设计之间的架构权衡是有用的。虽然 MASs 在模块化和并行性方面提供了潜在的优势,但它们也引入了额外的复杂性、协调开销和成本。以下表格总结了关键差异:

单代理设计 多代理设计
成本 较低:较少的推理步骤和较少的编排 较高:更多代理,更多 LLM 调用和工具使用
延迟 通常较低,流程简化 由于代理间通信可能较高
容错性 较低:代理故障通常会导致系统崩溃 较高:故障可以包含在单个代理内
模块化 单一且难以扩展 模块化:代理可以独立添加或替换
可扩展性 有限:代理处理所有逻辑 较高:并行代理允许分布式问题解决
通信开销 无(内部推理) 显著:需要显式的代理间消息传递
可解释性 较易:单一路径决策链 较难:分布式推理可能会降低透明度

表 11.1 – 多代理系统故障的潜在原因

如前表所示,多代理架构引入了一系列必须仔细平衡的权衡。虽然它们提供了模块化和潜在的故障隔离,但它们通常遭受更高的延迟、通信开销和协调挑战。这些权衡在 MASs 的经验评估中得到了反映。

图 11.7 – 五个流行的多代理 LLM 系统的故障率( https://arxiv.org/pdf/2503.13657 )

图 11.7 – 五个流行的多代理 LLM 系统的故障率(arxiv.org/pdf/2503.13657)

MASs 应该带来众多好处,例如更高的准确性、处理更复杂任务的能力、创建更复杂的计划或找到更好的解决方案。如果 MASs 没有带来所有这些好处,实际上往往还会失败,我们就需要了解其中的原因。在最近的一项研究中,Cemri 等人(2025)通过分析 150 个对话记录(每个平均超过 15,000 行文本)来对 MAS 失败进行详细的分类,并使用专家注释员识别失败及其原因。在他们的工作中,他们确定了 14 个原因,分为 3 个主要类别:

图 11.8 – MAS 失败模式的分类 (https://arxiv.org/pdf/2503.13657)

图 11.8 – MAS 失败模式的分类 (arxiv.org/pdf/2503.13657)

因此,三个主要类别如下:

  • 规范和系统设计失败:失败源于 MAS 设计的不足。对于作者来说,许多失败源于架构选择不当、代理之间对话管理不善、任务规范不良、违反约束以及代理角色和责任规范不良。换句话说,如果代理的指令不明确,系统可能会失败。即使指令明确,MAS 也可能不符合用户指令。

  • 代理间不匹配:失败源于无效的通信、合作不足、代理之间的冲突行为以及逐渐偏离初始任务。正如我们之前提到的,实现代理之间的高效通信并不容易。因此,一些代理可能无法高效地沟通,从而浪费资源。

  • 任务验证和终止:第三个重要类别包括未能完成任务或其过早终止。MASs 往往缺乏一种验证机制,该机制检查并确保交互、决策和结果的真实性、完整性和可靠性。简单来说,许多系统没有包括一个专门的代理(或其他机制)来监控过程并验证任务是否成功执行。

他们的调查结果显示,这些原因没有哪一个特别普遍,而是在各个系统中均匀分布。此外,一些原因之间存在相关性,产生了一种连锁反应。例如,错误的架构设计可能导致代理之间通信效率低下。

图 11.9 – 按类别和系统分布的失败模式 (https://arxiv.org/pdf/2503.13657)

图 11.9 – 按类别和系统分布的失败模式 (arxiv.org/pdf/2503.13657)

这项工作的结果表明,通过更仔细的设计可以避免失败。改进提示、代理通信以及添加代理(或其他验证机制)可以显著提高性能并降低失败的风险。在两个案例研究中,作者展示了这种情况。另一方面,这些建议不足以解决所有代理问题,但将进一步的技术进步。

除了系统本身之外,许多代理的限制也源于代理本身(即用于代理的模型)。在下一小节中,我们将讨论 LLMs 的推理限制。

推理的局限性

推理是人类的基本认知功能,很难给出一个精确的定义。维基百科这样定义推理:“推理是通过从新信息或现有信息中得出有效结论,有意识地应用逻辑,以寻求真理的能力。它与哲学、宗教、科学、语言、数学和艺术等具有人类特征的活动相关联,通常被认为是人类所拥有的区分能力。”

很长一段时间以来,人们都说只有人类才具备推理能力。然而,如今已经证明,灵长类动物、章鱼和鸟类也表现出基本的推理形式,例如做决定或解决问题。推理的一个问题是难以对其进行评估。通常,为了做到这一点,人们会评估解决复杂问题或做出决策的能力。复杂的解决问题需要识别问题、将其分解为子问题、寻找模式,然后选择最佳解决方案。决策同样需要识别问题和模式,并在选择最佳解决方案之前评估替代方案。

在 LLMs 的情况下,人们试图通过评估问题解决能力的基准数据集来衡量推理能力(例如 GLUE、SuperGLUE 和 Hellaswag)。如今,在这些数据集的许多情况下,人类已经被下一代 LLMs 超越。这些新的推理能力主要归因于三个因素:

  • 在所有针对推理的基准测试中,大型语言模型(LLMs)都表现出色。这些基准测试包含需要推理技能的数学或编码问题。这些基准测试的结果表明,LLMs 具有推理能力。

  • 随着参数、标记数量和计算预算的增加,新特性的出现。

  • 使用 CoT 等技术,这些技术允许模型发挥其潜力。

有的人质疑这种观点,声称这些基准测试中取得的成绩有其他解释。毕竟,许多作者认为 LLMs 不过是一群随机的鹦鹉。江在 2022 年(arxiv.org/pdf/2406.11050)提出,这些模型仅仅是模式匹配机器:“强烈的标记偏差表明模型依赖于输入中的表面模式,而不是真正理解底层 推理任务。”

在同一项研究中,观察到当 LLMs 遇到在预训练阶段未见过的、表现出与预训练阶段不同模式的新的示例时,它们无法泛化。如果我们更改示例中的标记,模式映射就会失败(一个通过上下文学习尝试在其知识中找到与用户提出的问题相似的示例的 Transformer)。当模型找不到示例时,模型就无法解决该问题。这种脆弱性和对训练示例的依赖性可以解释为什么模型在解决复杂问题时能够成功(它找到了模式),甚至在一些非常简单的问题上也会失败(它找不到示例)。这一点通过训练数据中示例频率与测试性能之间的相关性得到了证实。

例如,当模型被要求解决经典的“25 匹马”图论问题时,模型能够成功解决。如果将“马”标记改为“兔子”,模型就无法解决它。标记的改变与问题的底层逻辑无关,但模型因为难以映射问题而无法解决它。GPT-4 和 Claude 都因为动物名称和数字的扰动而出现了显著的性能下降。

图 11.10 – 使用经典问题进行标记偏差 (https://arxiv.org/pdf/2406.11050)

图 11.10 – 使用经典问题进行标记偏差 (arxiv.org/pdf/2406.11050)

这种现象被称为提示敏感性(对语义上等同于另一个提示的不同响应)。这一点通过 LLMs 对噪声敏感的事实得到了证实。它们很容易被不相关的上下文所干扰,这使得找到模式变得更加困难。这种敏感性并不能通过专门用于提高推理能力的提示技术得到解决,这表明干扰模式匹配活动会破坏推理能力。以下是一个不相关上下文干扰模式但不影响实际解决问题的例子:

图 11.11 – 不相关上下文干扰 LLMs (https://arxiv.org/pdf/2302.00093)

图 11.11 – 不相关上下文干扰 LLMs (arxiv.org/pdf/2302.00093)

一些作者建议,智能可以被视为一种涌现属性。生物系统自然倾向于变得更加复杂,这个过程是由自然选择驱动的。进化表明,随着时间的推移,智能有所增加,因为它促进了各种物种的适应性。当然,智能不是一个经济过程,大脑体积越大,消耗的资源(代谢消耗)就越多。损失函数可以被视为进化压力。由此可以推断,模型容量(就参数数量而言)的增加将与动物大脑中神经元数量的增加相平行,而损失函数将推动这些参数被有效地使用。通过扩大模型和训练(参数和训练令牌),LLMs 中也可能出现智能。因此,推理被视为从模型规模扩展中涌现出的属性。然而,后来的研究表明,LLMs 中的涌现属性可能是测量误差,并且整个理论与推理的涌现有关。

在下一张图中,你可以看到一些属性似乎随着模型规模的增加而出现。

图 11.12 – 涌现推理属性的示例(img/B21257_11_12.jpg)

图 11.12 – 涌现推理属性的示例(arxiv.org/abs/2304.15004)

根据其他作者的观点,大型语言模型(LLMs)具有推理能力,但需要被解锁。因此,CoT 提示(CoT prompting)通过中间推理帮助模型解锁其潜力,从而引导它在算术问题中找到正确答案。CoT 是今天的提示工程技术,也用于训练深度推理模型(如 ChatGPT-o1 或 DeepSeek R1)。实际上,这些模型是在用于进行监督微调的长 CoTs 上训练的。这些模型探索不同的推理路径来得出答案,显示出在推理基准测试中的显著提升。然而,一些研究表明,这些模型同时存在过度思考和思考不足的问题。

过度思考是一种奇特的现象,在这些模型解决特别简单的问题时,它们会进行比必要更长的时间的推理。模型会探索不同推理路径来回答简单问题。这表明模型无法理解哪些问题需要更多的努力。而思考不足则是其对立面,其中模型可能会放弃有希望的思考路径。这表明推理深度明显不足,模型没有完全达到正确解决方案。

同时,CoT 的好处也受到了质疑(arxiv.org/pdf/2409.12183):“在 MMLU 上,高达 95% 的总性能提升归因于包含“=”的问题或生成的输出。对于非数学问题,我们发现没有特征可以指示 CoT 何时会有帮助。”

图 11.13 – CoT 的改进仅限于符号和数学推理(img/B21257_11_13.jpg)

图 11.13 – CoT 的改进仅限于符号和数学推理(arxiv.org/pdf/2409.12183)

CoT 似乎有助于模型解决问题,因为它允许它利用在预训练期间学到的技能。CoT 简单地帮助制定计划,但然后 LLM 可能无法执行它。因此,CoT 可以用来获取计划,但要获得最大利益,必须添加外部工具(如 Python 解释器)。

图 11.14 – 一个 LLM 可以制定计划,但需要外部工具来更好地解决一些问题(img/B21257_11_14.jpg)

图 11.14 – 一个 LLM 可以制定计划,但需要外部工具来更好地解决一些问题(arxiv.org/pdf/2409.12183)

这些模型都是在与 Grade School Math 8K (GSM8K) 数据集相同的基准上测试的,该数据集提供了复杂的算术问题,但存在数据泄露的风险(考虑到训练一个 LLM 需要数十亿个标记,模型可能已经在训练中看到了答案)。

因此,在他们的研究中,Mirzadeh 等人修改了 GSM8K,保持了相同的问题,但使统计模式匹配变得困难。如果模型能够进行真正的推理,它应该能够轻松解决它;相反,如果它依赖于模式匹配,它就会失败。

在下面的图中,请注意 GSM8K 示例是如何修改的,以更好地控制 LLM 的响应。使用这个数据集,我们可以正式调查 LLM 的推理,并强调最先进的 LLM 表现出显著的性能变化;这表明 LLM 的推理是脆弱的。

图 11.15 – 这个数据集作为研究 LLM 假定的推理能力的一种工具(img/B21257_11_15.jpg)

图 11.15 – 这个数据集作为研究 LLM 假定的推理能力的一种工具(arxiv.org/pdf/2410.05229)

在测试最先进的 LLM 时,Mirzadeh 等人发现语言模型中没有形式推理的证据。当数值发生变化时,这些模型不够稳健,性能会下降,并且随着问题复杂性的增加,它们的性能会急剧下降。实际上,模型被添加的无关短语所欺骗。相反,模型考虑了这些短语,试图将它们映射到模型中,有时甚至将它们转化为操作。Mirzadeh 等人建议,这发生是因为他们的训练数据集中包含了需要转换为数学运算的类似示例:“例如,我们观察到的常见情况是,模型将关于“折扣”的陈述解释为“乘法”,无论上下文如何。这引发了这些模型是否真正充分理解数学概念的疑问。”

图 11.16 – 错误示例

图 11.16 – 错误示例(arxiv.org/pdf/2410.05229)

最近在 CoT(如 GPT4-o1)上训练的 LLM 也在这项任务中失败了。这表明 LLM 是复杂的统计模式机器,但并不具备真正的推理能力。

LLM 中的创造力

创造力与推理一起被认为是使人类成为人类的一种技能。如果量化推理是困难的,那么量化创造力是一项更加困难的任务。然而,创造力在我们成为人类的过程中扮演着非常重要的角色,它涉及到诸如写诗或书籍、创作艺术作品,甚至生成理论和实现突破性发现等活动。这就是为什么人们提出了 LLM 是否具有创造力的疑问。

调查 LLM 的创造力的问题在于我们没有明确的创造力定义。在研究领域,创造力通常被用作 Margaret Boden 选择的定义:“提出新颖、令人惊讶且有价值的思想或作品的能力。”尽管这个定义被接受,但评估其元素是困难的:

  • 价值:这是最容易定义的元素。例如,如果一个 LLM 生成的代码能够以自己的方式工作,那么它可以被认为是具有价值的。

  • 新颖性:对于一个对象要被认为是新颖的,它应该与已经创造出的东西不同。对于文本来说,新颖性可以被认为是与其他文本输出之间的差异。一个可能的定义是生成一个嵌入与其他不同文本距离较远的文本。

  • 令人惊讶:这被认为是定义中最重要且最困难的部分。随机重组的单词可以被认为是新的(或不同的),但肯定不是令人惊讶的(或是有价值的)。令人惊讶通常被理解为新颖的,但不是简单的变化或重组。

同时,Boden 描述了她认为与惊喜概念相关的三种创造性类型:

  • 组合性创造性:以不熟悉的方式组合熟悉元素(例如,将以前未结合过的两种类型)

  • 探索性创造性:以新的思维方式探索新的解决方案(例如,新的叙述风格,或对尚未探索的叙述风格的转折)

  • 转化性创造性:改变当前的叙述风格或当前思维方式

与这些定义一致,一些作者试图理解 LLM 是否具有创造性,如果是的话,它们能表现出什么样的创造性。这项研究的主要问题在于尝试量化 LLM 的创造性。一种方法就是评估 LLM 的输出是否可以映射到网络上的现有文本片段。人类的创造性受到先前作家的启发,但当作家创作原创作品时,这不能映射到先前作品中。如果 LLM 生成的每个文本都可以映射到其他文本,这将是缺乏创造性的压倒性证据。在一项最近发表的研究中,Lu(2024)分析了 LLM 生成的内容中有多少可以映射到互联网上的文本。这项研究的目的是精确地创建一个创造性指数,并比较 LLM 和人类。

图 11.17 – 将 LLM 输出映射到互联网文本( https://arxiv.org/pdf/2410.04265 )

图 11.17 – 将 LLM 输出映射到互联网文本(arxiv.org/pdf/2410.04265)

这种方法的成果表明,人类在创造性(基于独特的单词和句子组合)方面比 LLM(大型语言模型)表现得更为出色。LLM 中那微小的残余创造性可能仅仅源于随机过程以及我们不知道整个预训练数据集的事实。

图 11.18 – 人类与 LLM 的创造性指数比较( https://arxiv.org/pdf/2410.04265 )

图 11.18 – 人类与 LLM 的创造性指数比较(arxiv.org/pdf/2410.04265)

Lou 等人提出一个有趣的类比:“正如 DJ 混音现有曲目而作曲家创作原创音乐一样,我们推测 LLM 更像 DJ,将现有文本混合以产生令人印象深刻的新输出,而熟练的人类作者,类似于音乐作曲家,创作原创作品。”

尽管 LLM 无法实现真正的创造性,但有几项研究试图提高模型的伪创造性(从长远来看,LLM 可能特别重复)。这里有三种潜在的策略:

  • 对 LLM 超参数的操作:第一种策略与提高 LLM 的温度相一致。温度控制生成过程中的不确定性或随机性。调整温度会影响模型生成,在低温(例如,0.1–0.5)下,模型生成确定性、专注和可预测的输出。提高温度会生成更不可预测的输出。超过 2.0 后,过程变得混乱,模型生成无意义的内容。因此,对于需要创造力的应用,你可以探索更高的温度,但请记住,这通常也会导致一致性的降低。

  • 对 LLM 进行额外训练:使用后训练技术是今天广泛探索的一条途径。后训练技术用于模型对齐和使模型更易于执行任务。一些作者提出了使用旨在激励输出多样性的技术。

  • 提示策略:使用试图迫使模型更具创造性的提示。然而,提示策略似乎没有取得很好的效果。

机制可解释性

人工智能的最近进展意味着模型能力迅速提升。矛盾的是,自监督学习的范式意味着即使模型是由人类设计的,LLM 的能力也不是预先设计的。理论上,开发者只需要了解过程,而不必理解模型是如何工作的,因为期望的特性在训练过程中出现。换句话说,LLM 不是为展示的特性而设计的;这些特性是通过扩展获得的,而它如何到达那里的大部分内容是不清晰的。重建它们出现的方式和这些能力背后的机制不是一项容易的任务,尤其是在训练了数十亿参数的模型之后。这些模型被认为是黑盒,最近,有一些关于如何分析它们的讨论。

模型(如以下列表和图所示)有几种可解释性类型。这些可解释性的类型各自关注不同的方面。

图 11.19 – 模型的逐步解释级别 (https://arxiv.org/pdf/2404.14082)

图 11.19 – 模型的逐步解释级别(arxiv.org/pdf/2404.14082)

我们可以将各种可解释性方法分为以下几类:

  • 行为:将模型视为一个黑盒,并关注输入和输出之间的关系。这种范式考虑了那些对模型无差别的可解释性经典方法。

  • 归因:这些方法试图通过跟踪输入的每个组件的贡献来理解模型的决策过程,并基于梯度偏移。

  • 基于概念:使用探针来尝试更好地理解模型学习到的表示。

  • 机制:这是一种对组件及其组织方式的细粒度分析,试图识别因果关系。

机制可解释性旨在通过识别产生其输出的机制来揭示神经网络的内部决策过程。我们关注这种方法,因为它强调理解模型的各个组成部分及其对整体行为的影响。这种视角很有价值,因为它使我们能够通过全面和透明的视角来分析模型。

机制可解释性超越了之前的方法,因为它寻求识别导致神经网络泛化的因果机制,以及背后的决策过程。随着模型及其能力的增长,人们提出了一个问题,即这些模型是如何获得这些泛化能力的,因此需要全局解释。

尽管大型语言模型(LLMs)生成的文本与人类产生的文本相似,但这并不意味着概念和认知过程的表示是相同的。这一点可以通过以下事实得到证明:LLMs 在某些任务上表现出超越人类的能力,而在对人类来说简单的其他任务上,它们却表现得非常糟糕。我们需要一种方法来解决这个悖论,那就是通过机制可解释性。为了尝试解决这种不一致,提出了对 LLMs 的反向工程。反向工程(一种机制可解释性方法)包括三个步骤:将模型分解成更简单的部分,描述这些部分如何工作以及它们如何相互作用,并测试这些假设是否正确。虽然机制可解释性旨在揭示网络内部的逻辑和因果机制,但基于概念的可解释性则侧重于理解模型如何表示高级、人类可理解的概念,以及这些概念如何影响模型的决定,从而为预测背后的推理提供洞察,并弥合人类认知与机器学习过程之间的差距。这两种方法在以下图中展示:

图 11.20 – 反向工程 (https://arxiv.org/pdf/2501.16496)

图 11.20 – 反向工程 (arxiv.org/pdf/2501.16496)

这种方法的缺点是难以将神经网络分解为功能组件。实际上,在神经网络中,神经元是多义的,代表多个概念。因此,单个组件的解释并不很有用,反而可能具有误导性。作者们现在专注于尝试将多个神经元甚至多层神经元分解为功能单元。由于这些概念由多个神经元(叠加假设)表示,因此尝试使用强制稀疏性的工具来分解这种稀疏表示。

图 11.21 – 使用 SDL 分解叠加表示(img/B21257_11_21.jpg)

图 11.21 – 使用 SDL 分解叠加表示(arxiv.org/pdf/2501.16496)

这种将模型分解为包含多个神经元和层的功能单元的转变需要新的技术。

稀疏字典学习(SDL)包括多种方法,允许对模型学习的内容进行稀疏表示。稀疏自动编码器(SAEs)是这种方法之一,它允许我们学习与模型特性相关联的稀疏特性,并使模型学习的内容更加易于访问。SAEs 使用编码器和解码器来稀疏化模型内的叠加表示。

图 11.22 – 将 SAE 应用于 LLM 的示例(img/B21257_11_22.jpg)

图 11.22 – 将 SAE 应用于 LLM 的示例(arxiv.org/pdf/2404.14082)

SAEs 允许我们识别出可被人理解的特性,并通过稀疏性,我们尝试学习少量特性。在基本层面上,SAEs 可以提取与单个单词或标记相关的特性,例如单词频率特性(对应于高频与低频单词的激活),以及词性特征(选择性激活名词、动词或形容词)。SAEs 通常捕捉 LLMs 中嵌入的句法规则,例如为某些句法模式(例如主语-谓语-宾语结构)触发的激活,或对应于句法依赖性的特征,例如一个单词是否是修饰另一个名词的名词。此外,还可以识别高级特性,例如针对特定领域(例如政治、科学或体育)的文本触发的神经元,以及句子是否表达积极、消极或中性情感。最后,一些特性也可能与写作风格和话语结构相关,例如区分学术写作和日常对话,编程语言与人类语言,或特定作者的独特写作风格(例如莎士比亚与 X/Twitter 帖子)。

图 11.23 – SAE 训练概述(img/B21257_11_23.jpg)

图 11.23 – SAE 训练概述 (arxiv.org/pdf/2309.08600)

SAEs 学习到的某些特征可能并不反映真实知识,而是模型嵌入的随机统计属性。此外,SAEs 有时在隐藏层中学习到虚假的相关性,而不是有意义的概念结构。还有,SAEs 只关注一次一层,没有考虑到不同层的不同神经元可能对同一概念进行交互。尽管存在相关成本,但 SAEs 被认为是一种分析模型行为的很有前途的方法。同时,提出了以更可解释和分散的方式训练 LLMs。在模型权重中使用稀疏性有助于可解释性。例如,剪枝和其他类似技术将零引入模型权重,有效地将其擦除。稀疏性消除了神经元之间的连接;这使得跟踪信息流和更好地理解模型的决策过程(或连接输入和输出的关系)变得更加容易。专家混合(Mixture-of-experts)也有类似的效果,因此使其更具可解释性。

可解释性技术现在是理解 LLMs 行为和防止危险行为出现的关键,例如欺骗用户、显示偏见、给出错误答案以取悦用户的信仰(称为“拍马屁”)以及学习虚假的相关性。随着参数和训练的增加,模型在响应上变得越来越复杂,越来越冗长,具有说服力,这使得用户难以理解答案是否正确。此外,这些模型现在已向公众部署,这意味着有恶意意图的用户可以进行数据中毒、越狱、对抗性攻击等攻击。可解释性有助于监控模型与公众互动时的行为,突出失败的地方,并在实时中解决它们。可解释性是模型安全的重要要求,因为它不仅允许我们识别问题行为,还可以识别哪些组件负责这些行为。一旦我们确定了与意外行为相关的组件,我们就可以进行干预。

此外,如今对隐私的关注越来越多,机器反学习是处理清除特定数据点对训练的机器学习模型影响的领域。例如,监管问题可能要求我们从模型中删除有关个人的信息。机器反学习涉及尝试删除这些信息,而无需从头开始训练模型。机器反学习与可解释性相关,因为分解技术使我们能够在模型参数中定位概念和信息。更普遍地说,我们希望有能力编辑模型知识(例如纠正事实错误、删除受版权保护的内容或消除有害信息,如武器制造说明)。编辑需要能够以手术般的方式干预模型参数,而不会破坏额外的知识和其他能力。编辑比反学习更复杂,因为它意味着重写模型知识。可解释性技术使我们能够了解编辑或反学习是否成功,然后监控整个过程。

可解释性在尝试预测模型在新情况下将如何表现,从而避免安全风险方面也很有用。实际上,模型的某些行为可能仅在未预料到的情况下出现,而在进行标准评估时可能不会表现出来。例如,我们可以在用户发现之前识别出易受攻击性或潜在的后门。考虑到今天的 LLMs 越来越多地与工具连接,任何滥用都可能产生传播效应。例如,如果 LLM 连接到金融数据库,它可能被用来提取有关用户的信息。或者,一个在线购物的 LLM 可能被用来进行欺诈和购买假冒产品。微调和其他训练后步骤可能导致在预训练模型中不存在的行为出现或加剧。此外,一些属性似乎在规模上出现,而在我们训练较小模型时难以预测。在为新架构设计时,通常训练最终架构的较小版本。较小的模型可能不会出现仅在规模上出现的问题。

可解释性也有值得称赞的重要方面;理解模型及其组件的行为使我们能够加快推理速度。例如,如果某些计算是不必要的,我们可以将其关闭,或者利用获得的知识提炼出一个更有效的模型。此外,我们还可以识别出影响正面或负面推理的组件。

可解释性的另一个有趣方面是它可以用于新的发现(通常称为显微镜 AI)。换句话说,你可以调查一个在特定数据上训练过的模型,并可以使用可解释性技术来深入了解它。你可以使用这些技术来识别可能逃过了人类注意力的模式。例如,在 AlphaZero 在象棋中击败人类成功之后,研究人员考虑从模型中提取信息以识别人类可以学习到的关于牺牲的概念。在这篇论文中(arxiv.org/abs/2310.16410),Schut 等人(2023)确定了这些概念或模式,以了解模型对游戏的表示有何不同。

图 11.24 – 从机器独特知识中学习 (https://arxiv.org/pdf/2310.16410)

图 11.24 – 从机器独特知识中学习 (arxiv.org/pdf/2310.16410)

大型语言模型(LLMs)拥有庞大的记忆,人类通过语言来表达自己;这使得它们能够分析和进行关于人类心理的假设。因此,可解释性是一种让我们不仅能更好地理解模型,还能将模型作为工具更好地理解人类的方法。在下一节中,我们将讨论模型如何有可能接近人类智能。

通往通用人工智能之路

“通用人工智能(AGI)是一种假设的高度自主的人工智能(AI)类型,它将在大多数或所有具有经济价值的认知工作中匹配或超越人类的能力。它与窄 AI 形成对比,后者仅限于特定任务。另一方面,人工超级智能(ASI)指的是大大超出人类认知能力的人工智能。AGI 被认为是强人工智能的一种定义。”

这是维基百科对通用人工智能(AGI)的定义。在想象能够超越人类的 AI 之前,我们必须问一问 AI 是否已经赶上了人类的能力。一般来说,在 ChatGPT 出现之前,这场辩论并未开始(至少对于公众来说是这样)。这是因为之前的模型仅在特定应用中具有超越人类的能力。例如,AlphaGo 能够相对容易地击败人类冠军,但没有人认为我们之所以是人类是因为我们懂得如何下围棋。另一方面,DALL-E 和 ChatGPT 等模型已经开始在公众中引发疑问。毕竟,创作艺术或创意写作是与人类普遍相关的技能。当 ChatGPT 和其他大型语言模型能够通过大学或医学和法医执照考试时,这种感觉得到了加强。

我们在之前的子节中讨论了创造力和推理。目前的共识是,LLMs 没有展现出真正的推理或创造力技能。它们是复杂的随机模式机器,它们在整个人类知识中寻找模式的能力使它们非常有效。

如果 LLMs 今天无法展现出人类智能的水平,人们可能会想知道这会对 AGI 带来什么。到目前为止,人们一直认为,通过扩展参数和训练就可以实现 AGI。根据涌现属性的理念,推理和创造力应该在扩展过程中某个时刻出现(通过增加模型的大小和用于训练的标记数量,尽管我们无法预测,模型应该开始显示出真正的推理)。今天,大多数研究人员都不相信这是可能的,也不认为后训练技术足够。

此外,扩展并不是无限可能的。即使我们能够投入巨额资金和资源,也无法创造出线性增长的模型所需的足够文本。实际上,人类产生的文本数量是有限的,我们正在接近人类产生文本量的极限。

图 11.25 – 公共文本和数据使用量的预测(img/B21257_11_25.jpg)

图 11.25 – 公共文本和数据使用量的预测(epoch.ai/blog/will-we-run-out-of-data-limits-of-llm-scaling-based-on-human-generated-data)

解决这个问题的方法可能是使用合成数据。然而,合成数据可以被看作是一种“知识蒸馏”,可能会导致模型崩溃。使用合成数据进行训练的模型会进入崩溃状态,显示出性能迅速下降。

图 11.26 – 不同重训练数据集组成下迭代重训练后生成的示例,从 0%合成数据到 100%合成数据(img/B21257_11_26.jpg)

图 11.26 – 不同重训练数据集组成下迭代重训练后生成的示例,从 0%合成数据到 100%合成数据(arxiv.org/pdf/2311.12202)

如果扩展不是解决方案,一些研究人员提出,关键在于开发一个“世界模型”。也就是说,就像人脑构建外部环境的内部表示一样,构建这样的结构化表示可能是提高 LLMs 能力的关键。这种表示用于想象可能的行为或行为的后果。此模型还将用于将我们在一个领域中学到的任务泛化并应用于另一个领域。今天,一些研究人员认为 LLMs 有一个基本的世界模型,并且这也可以被可视化。例如,Gurnee(2023)指出,LLMs 在训练期间形成了一个基本的世界模型,并且它显示了时空表示。

图 11.27 – Llama-2-70b 的空间和时间世界模型 (https://arxiv.org/pdf/2310.02207)

图 11.27 – Llama-2-70b 的空间和时间世界模型 (arxiv.org/pdf/2310.02207)

这些时空表示远未构成一个动态因果世界模型,但它们似乎是其演化的第一个元素。然而,关于这些世界模型是否能够演变成可以用于进行模拟或学习因果关系的稳健和可靠模型,还没有达成共识。例如,在一项研究中(Vafa,2024),变压器未能创建一个可靠的纽约市地图,该地图可用于进行预测,然后用于引导。

图 11.28 – 由三个模型生成的序列重建的曼哈顿地图 (https://arxiv.org/pdf/2406.03689)

图 11.28 – 由三个模型生成的序列重建的曼哈顿地图 (arxiv.org/pdf/2406.03689)

当然,语言中有大量的信息可以学习,这使得 LLMs 能够解决大量任务。然而,一些研究人员认为这还不够,并且模型应该被具身化(在物理代理中使用并能够与物理环境进行交互),以便真正实现质的飞跃(包括能够学习更稳健的世界模型)。迄今为止,这还是一个假设,仍然是一个未解决的问题。

伦理问题

最近发表的一篇文章建议不应开发完全自主的人工智能代理(Mitchell,2025)。虽然这听起来可能有些极端,但它仍然强调了自主代理可能带来的风险:

人工智能代理的发展是人工智能中的一个关键转折点。正如历史所证明的,即使是精心设计的自主系统也可能因为微不足道的原因而犯下灾难性的错误。虽然增加自主性可以在特定环境中提供真正的益处,但人类的判断力和情境理解仍然至关重要,尤其是在高风险决策中。

作者为智能体定义了一系列级别,其中人类逐渐将过程控制权让渡给智能体,直到 AI 智能体完全接管。人工智能的最新进展展示了我们正逐步接近创造由智能体负责整个过程的流程。

图 11.29 – 智能体级别( https://arxiv.org/pdf/2502.02649 )

图 11.29 – 智能体级别(arxiv.org/pdf/2502.02649)

在第三章中,我们讨论了与大型语言模型(LLMs)相关的风险,而在这个小节中,我们想要详细讨论与 AI 智能体相关的风险。显然,许多智能体系统的风险源于 LLMs(LLM 是智能体系统的核心),但通过工具扩展 LLM 的能力会创造或加剧新的风险。

在详细讨论一些风险之前,我们想讨论生成式 AI 中一个最不被低估的风险:即拟人化智能体的风险。正如我们之前提到的,LLMs 没有意识水平,也不会产生真实情感。LLMs 模仿它们训练时所使用的分布;这使得它们看起来好像可以模仿情感(这显然并不意味着它们实际上拥有或表达情感)。在与包含 LLM 的聊天机器人或其他社交应用互动时,必须考虑到这一点。“感知到的情感”不仅影响用户,还影响必须解释智能体结果的研究人员。它们模仿情感的能力可以成为模拟人类行为的研究的有效工具,但过度拟人化可能会产生错误信息和结果归因的错误。此外,拟人化可能导致用户与 AI 智能体之间形成准社会关系(当智能体具有实体形态并能够进行物理交互时,这种风险将更大)。

与拟人化风险相关的是对用户过度影响的风险。存在用户过度依赖和过度自信于智能体的风险。无论是由于错误(如幻觉)还是恶意行为(投毒或黑客攻击),用户都应该对智能体的行为持足够的怀疑态度。影响风险被认为是一组影响用户行为和信念的风险:

  • 说服力:指的是模型影响用户行为的能力。当智能体强迫用户做出变革性选择或请求有害行为时,这可能会特别有问题。

  • 操纵:指的是绕过个人的理性能力(如信息误述或利用认知偏差)以影响决策的代理人。这种行为也可能作为不良设计选择的结果出现,创造一个让用户保持参与的产品,或者为了创造信任而进行个性化。这在道德上是存在问题的,因为它不尊重用户的自主权,并可能迫使用户采取对自己有害的行为。

  • 欺骗:指的是导致个人形成错误信念的策略。这很可能会推动用户采取可能对自己有害的行为,因为他们被错误的信念所迷惑。

  • 胁迫:意味着个人选择某事物是因为他们没有其他可接受的替代方案。这种风险可以是物理的(具有具身化代理)或心理的(也是聊天机器人)。

  • 剥削:意味着利用个人的情况获得不公平的便利。AI 代理可以被编程为具有剥削性(我们可以想象一个在赌场中试图推动用户尽可能多花钱的 AI 代理)。

这些行为可以被恶意行为者利用。例如,代理人的说服技巧可以被用来在网络上传播错误信息。LLM 能够生成大量的文本,看起来似乎具有权威性。一个 LLM 本身可以产生幻觉,但它可以被用来有目的地生成具有特定目的的虚假新闻。使用代理允许 LLM 使用额外的工具(生成图像和视频以及检索信息)并将它们直接输入到通信渠道。矛盾的是,由于这种虚假新闻难以被人类拦截,因此代理也可以被用来对抗 AI 生成错误信息的传播。代理可以用来大规模生成错误信息,生成成本逐渐降低(并且仍然低于雇佣人类)。此外,代理使得搜索有关受害者的信息成为可能,从而生成定制内容以更有效地传播。

错误信息可以被用来加强个人或群体的偏见。这种内容(文本、图像、音频和视频)可以被用来影响政治选举或激起公民的愤怒。此外,除了虚假信息之外,代理人还可以产生其他类型的有害内容,包括裸露、仇恨或暴力的描绘。

图 11.30 – 在 LLM 时代对抗错误信息的机遇与挑战( https://arxiv.org/pdf/2311.05656 )

图 11.30 – 在 LLM 时代对抗错误信息的机遇与挑战(arxiv.org/pdf/2311.05656)

恶意行为者也可以利用代理进行其他目的,如网络钓鱼攻击、网络攻击或诈骗。事实上,LLMs 也可以生成有害代码,可用于窃取金钱或信息。聊天机器人可以用于赢得信任并说服某人分享信息或收益。还有狡猾的方法攻击代理;例如,我们可以想象一个为用户进行购买的代理可能被恶意行为者渗透,并诱使它进行欺诈性购买。计划在医疗保健、法律、教育和科学等领域部署 AI 助手,将增加可能造成的风险和严重性。此外,许多 AI 代理今天都是原生的多模态(多种可能的输入和输出类型)并利用能够进行更多推理和规划的深度推理模型。此外,与 LLMs 不同,它们还集成了记忆系统,所有这些都增加了风险。例如,一个负责进行网络攻击的代理可以从记忆中检索成功的过去攻击或丢弃过时的技术,搜索在线漏洞的信息,生成和执行代码,并制定多步骤策略。正如所见,恶意行为者可以通过多种方式干扰 LLM,例如通过提示注入或信息提取。LLM 在训练期间获取敏感信息,这些信息可以被提取。代理可以连接到敏感数据库,并且有技术使 LLMs 提取内容。此外,代理的滥用还可以由威权政府进行。例如,政府可能使用代理生成虚假信息或审查,并可能用于监视、追踪和压制异见。高级代理系统可以从手机、汽车、物联网等更多地方提取数据,使控制人口变得更加容易。

另一个风险是这些代理的经济影响。AI 预计将在生产率、就业、工作质量和不平等等方面对经济产生重大影响。代理和 AI 的普遍使用与不同的相关风险相关:

  • 就业: 不同的研究估计,47%的工作面临自动化的风险,尤其是那些以常规和体力劳动为特征的工作,如驾驶和制造业。LLMs(大型语言模型)的进步也引起了人们对涉及生成和操作信息的工作的担忧,这些工作通常与较高的教育水平相关,如翻译、税务顾问,甚至是软件工程师。因此,AI 可能会加速对需要熟练劳动力的职位造成的工作流失,而不会创造足够多的职位来吸收这些被取代的工作。

  • 工作质量:一些初步研究表明,使用人工智能可以使工人更有效率,并提高工人的工资。然而,一些研究却强调,雇主可能更有效地以更大的压力监控他们的员工。其他研究指出,机器人的引入可能会减少制造业的体力劳动,但会迫使工人更快地工作,减少人际接触并增加监督。

  • 不平等现象:一方面,技术发展已经缩小了不同国家之间的不平等。同时,国内收入不平等加剧,贫富差距更加明显。关于人工智能可能如何影响不平等的研究不多,但一些研究表明,企业能够通过提高生产力和收入来更好地利用人工智能,而工人则面临被取代的风险,从而收入减少。一些研究提出,高收入职业可能从使用人工智能中受益,而另一些职业则可能受到影响。例如,人工智能助手似乎通过减少初级职位来影响这些职位。此外,大多数领先的 AI 研究实验室、初创公司和企业都位于某些地理区域,存在高薪职位集中的风险。相反,人工智能也创造了低薪工作,尤其是在数据创建和数据采集方面。

到目前为止,人工智能工具还不够复杂,无法取代人类,但一些对就业的影响已经显现。例如,ChatGPT 和 DALL-E 等工具已经对“创意经济”(包括作家、艺术家、设计师、摄影师、内容创作者等)产生了影响,减少了职位和收入。

另一个风险是生成式人工智能的环境影响。数据和计算是 AI 系统训练和使用的基础。因此,需要硬件和基础设施(包括数据中心和电信)来创建和使用代理。创建必要的硬件会产生环境影响(稀土元素的开采、运输所需的能源、工厂用水以及化学物质的使用)。然后,一个模型需要能源来抽取、构建和部署(运营成本)。除了训练之外,推理部署也需要资源和能源消耗。与 LLM 训练相关的能源消耗和相应的二氧化碳排放量随着时间的推移而增加。如图所示,二氧化碳的产生与训练能耗呈线性增长(直接相关于参数数量和训练的增加):

图 11.31 – 不同模型估计的能耗(千瓦时)和二氧化碳(千克)

图 11.31 – 不同模型估计的能耗(千瓦时)和二氧化碳(千克)(arxiv.org/pdf/2302.08476)

考虑到每天使用 LLM(或包含 LLM 的服务)的用户数量不断增加,训练对排放的影响只是其中的一小部分。今天,推理被认为越来越重要(据估计,2019-2021 年间谷歌 60%的机器学习能源消耗归因于推理)。

这些是 LLM 和代理可能存在的风险。截至目前,正在研究策略来尝试解决和减轻这些风险。

摘要

本章介绍了某些行业将如何被代理所革新。人工智能革命不仅限于这些行业,还将产生大规模的影响。然而,本书提供了一个严肃且结构化的技术组件介绍,这将推动这场革命,为您提供理解未来(以及已经到来的未来)的工具。除了这种技术革命可能激发的惊奇感之外,我们还想提醒您,仍然存在不应忽视的技术和伦理挑战。

本章结束了这本书,但为未来留下了一系列问题和挑战。跟随我们到这一点的读者可以在最后一章中找到关于如何利用他们在行业和研究层面所学到的知识的建议。

进一步阅读

posted @ 2026-03-25 13:17  布客飞龙I  阅读(112)  评论(0)    收藏  举报