【LLM】如何将开源基础模型训练成特定领域的LLM？

  🔎大家好，我是Sonhhxg_柒，希望你看完之后，能对你有所帮助，不足请指正！共同学习交流🔎

📝个人主页－Sonhhxg_柒的博客_CSDN博客 📃

🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝​

📣系列专栏 - 机器学习【ML】 自然语言处理【NLP】  深度学习【DL】

 🖍foreword

✔说明⇢本人讲解主要包括Python、机器学习（ML）、深度学习（DL）、自然语言处理（NLP）等内容。

如果你对这个系列感兴趣的话，可以关注订阅哟👋

文章目录

什么是基础模型？​

什么是LLM？

LLM Stack — 简单视图​编辑

 什么是特定领域的LLM？

使用特定领域的LLM有哪些好处？

提高任务熟练度

提高效率

卓越的泛化能力

增强的可解释性

构建特定领域的定制LLM的挑战

数据挑战

技术挑战

道德挑战

资源挑战

金融专业LLM BloombergGPT 的详细案例研究

BloombergGPT 可以执行哪些任务？

像 BloombergGPT 这样的特定领域 LLM 的架构

BloombergGPT 是如何训练的？

第 1 步：构建 FinPile 数据集

第 2 步：Tokenization

第 3 步：构建模型

第 4 步：训练模型

第 5 步：大规模优化

BloombergGPT 如何处理道德和隐私问题？

如何将开源基础模型训练成特定领域的LLM？

第1步：加载数据集

第 2 步： Tokenizaton

第 3 步：创建数据加载器以准备训练数据

第 4 步：定义模型架构：向神经网络添加 3 个层和 1 个二进制输出层

第 5 步：通过预训练的BERT来准备损失函数

第 6 步：训练模型

第 7 步：评估模型

第 8 步：运行管道以迭代训练和评估模型并获取每个 epoch 的输出

总结

---

在快节奏的企业环境中，技术创新始终是催化剂，以惊人的速度推动业务增长。最近成为话题并带来范式转变的一项技术进步就是生成式人工智能。如今，每个行业都受到生成式人工智能的深刻影响，这预示着大语言模型（LLM）广泛使用所定义的新时代的到来。不同行业的企业实体越来越认识到定制大型语言模型以前所未有的方式增强其业务运营的巨大潜力。由于对增强控制、更好的数据隐私和经济高效的方法的需求不断增长，企业正在逐渐摆脱通用的、通用的模型。随着组织越来越多地利用定制的力量，他们打开了一个世界的大门，在这个世界中，智能系统将彻底改变从创新和效率到运营流程核心的一切。

通用LLM是在大型且多样化的数据集上进行培训的，而特定领域的LLM是专门为特定领域设计的，并在满足组织特定要求的专有数据集上进行培训。通用LLM对许多企业都有用，但特定领域的LLM更适合在特定领域内需要准确且适合上下文的输出的情况。这些模型的性能通常优于作为ChatGPT基础的 GPT-3.5 等广泛模型，具有高度针对性，并且可能更高效。

众多开源基础模型的可用性进一步推动了这一重大变化，使企业可以制作个性化的LLM以满足其独特的需求并实现最佳结果。

特定领域的LLM正在得到广泛采用，因为它们可以适应特定要求，更有效地利用可用资源，并提供强大的语言处理能力来应对特定的挑战和任务。他们准备开创具有增强适应性、足智多谋和效力的高级语言处理解决方案的新时代。

本文提供了对特定领域LLM的详细见解，涵盖其优势、开发过程中涉及的挑战以及如何利用开源基础模型的潜力创建特定于行业的LLM等方面。所有这些都将帮助您了解人工智能这一令人着迷的进展的复杂性。

什么是基础模型？

“基础模型”一词是由斯坦福大学研究人员提出的，用于描述新型机器学习模型。这些模型不是为图像识别等特定任务而设计的，而是使用大规模自我监督学习在广泛、多样化的数据集上进行训练，从而可以针对各种下游任务进行微调。

与名称所暗示的相反，基础模型 (FM) 并不是人工智能的基石，也不暗示 AGI（通用人工智能）。这些模型本身是独特且卓越的，具有五个主要特征：

1. 预训练：FM 使用大量数据和强大的计算能力进行了预训练，无需进一步训练即可使用。
2. 泛化：与针对特定任务的传统人工智能模型不同，FM 具有多功能性，旨在解决众多任务。
3. 适应性：FM 可以通过提示进行调整，这意味着它们可以响应用户定义的输入（例如文本）。
4. 大规模：FM 的模型规模和数据规模都很大。例如，GPT-3 拥有 1750 亿个参数，并接受了大约 5000 亿个单词的训练。
5. 自我监督：FM 从没有明确标签的数据模式中学习。

FM 的著名例子包括 GPT-3 和 DALL-E-2。这些模型使日常用户和非开发人员能够通过提供简单的“提示”来执行出色的任务。

经过培训后，FM 可以管理大量数据类型和任务，使其具有高度适应性。当与适当的运营链配合使用时，它们可以自动化复杂的工作流程。除了生成文本、图像、音频和视频等内容之外，FM 还可以用于预测和分类任务，这一概念称为判别建模。

FM 开启了知识工作的变革时代，促进了语言相关任务、推理、搜索和计算机视觉的改进，特别是与其他机器学习方法（例如带有人类反馈的强化学习）相结合时。CLIP 和 ViLBERT 等多模态FM的开发正在进行中，这些模型可以显着增强机器人技术。通过使用小样本学习和领域专业化等方法，FM 可以解决众多挑战。

尽管 FM 潜力巨大，但也有其局限性。其中包括编造答案（称为幻觉）、时间转移或持续适应的问题、训练所需的大数据集和大量计算资源，以及微调的人工评估的需要。其他障碍包括 FM 训练数据的专业化和多样性之间的紧张关系、最佳适应方法的不确定性以及对模型内部工作原理的有限理解：模型可以做什么、为什么会产生某些行为以及如何实现这一点。

什么是LLM？

大型语言模型 (LLM) 代表旨在理解和生成文本的基础模型的子类。通过摄取大量文本数据并拥有数十亿个参数，这些模型可以根据用户提供的提示执行各种任务。我们日常遇到的功能，例如搜索引擎中的自动完成或电子邮件平台中的智能撰写，都是这些语言模型的现实应用。他们擅长根据提供的文本预测最可能的后续单词或短语。

要理解LLM，我们应该认识到它们是建立在称为变压器的先进神经网络之上的。这些转换器从大量文本数据中提取模式，从字符串到数字再到代码。值得注意的是，LLM的创建和利用涉及巨大的障碍：海量数据集、相当大的计算能力和专业技能是训练、微调和从这些模型中提取见解的先决条件。这解释了为什么只有少数模型（例如 BERT 和 GPT-3）易于访问，以及为什么许多模型仍然是闭源的。

尽管LLM具有潜力，但不应将其与通用人工智能 (AGI) 混为一谈。目前的LLM并不本质上理解概念和抽象。它们有局限性，但仍然是自然语言处理 (NLP) 领域最有效的工具，适用于各种任务。它们的潜在应用涵盖从编码到协助完成任务，再到撰写连贯且引人入胜的叙述。

LLM的输出通常在生成响应之前经过严格的过滤。此过程对于确保生成的内容真实且安全至关重要，考虑到与这些模型相关的风险，这一点至关重要。由于企业希望利用LLM来开发特定的产品或系统，因此高度的监督和治理变得至关重要。

LLM的历史历程可以追溯到2010年代初期。最初，使用带注释或标记的数据进行迁移学习是一种普遍的做法。然而，这种方法成本高昂，难以一致实施，并且会带来隐私问题。2017 年左右基于 Transformer 的模型的出现标志着一个重大的进步，GPT-3 和 ChatGPT 等模型首次亮相并迅速流行。

在后 ChatGPT 世界中，LLM不断展现出对各种应用的前景。他们可以用简单的术语解释复杂的主题、翻译语言、生成创意内容、集思广益、协助完成在线任务、提供客户服务，甚至执行技术功能。然而，它们并非没有缺陷。答案的可靠性和捏造答案的风险（通常称为“模型幻觉”）凸显了进一步完善这些模型的必要性。

因此，虽然LLM具有变革潜力并正在重塑复杂的人工智能格局，但它们需要仔细管理和持续改进，以确保它们在不影响安全性和准确性的情况下充分发挥潜力。

LLM Stack — 简单视图

 什么是特定领域的LLM？

特定于领域的语言模型构成大型语言模型的专门子集，致力于在特定领域内生成高度准确的结果。与旨在以令人满意的熟练程度处理各种主题的广义LLM不同，特定领域语言模型专注于在预定义领域内优化其性能，该领域的范围可以从法律或医学等技术领域到更休闲的领域，例如烹饪艺术。

训练特定领域语言模型的方法取决于获取大量特定领域数据。这些数据用作训练集，确保模型沉浸在与所选领域相关的复杂上下文和特定知识中。

进行特定领域的预训练有两种主要策略。第一个策略涉及初始化预训练的 LLM 并使用特定领域的数据对其进行微调，以使其功能适应新的环境。这种方法通常可以实现更快的收敛并且通常具有优越的性能。另一种策略是使用特定领域的数据从头开始构建新的LLM。最佳策略可能会根据应用程序和相关领域的不同而有所不同。

然而，这种专业化需要一个基本的权衡。特定领域的语言模型，例如专门针对烹饪食谱进行训练的模型，可以比通用模型更熟练地理解其专业领域的微妙之处。然而，当面临其训练领域之外的任务时，其性能会显着恶化。另一方面，通用LLM拥有更广泛的知识，尽管没有特定领域语言模型的细粒度专业知识。

这种差异与我们在现实生活中看到的专业知识类似。能够同时提供熟练的股市分析的专业厨师或兼任多才多艺的艺术家的数学家是极其罕见的。相应地，开发一个可以在领域之间无缝过渡同时保持高度熟练的LLM是一个挑战。知识广度和深度之间的权衡是语言模型设计所固有的，因此需要在开发过程中进行明智的考虑。

下表比较了一般LLM和特定领域LLM：

标准	普通LLM（例如 GPT-3）	特定领域的LLM（例如 FoodUDT-1B）
目的	旨在理解和生成跨广泛主题和上下文的文本。	专门设计用于理解和生成特定领域或领域的文本。
训练数据	接受过各种互联网文本的培训，涵盖广泛的主题	针对特定领域的数据进行训练（在本例中为 500K 菜谱）。
知识深度	对广泛的主题有一般的了解，包括高层次的特定领域主题。	对特定领域有深入的了解。
上下文的表示	基于对语言和世界知识的广泛理解来表示文本和上下文。例如，“apple”更接近“iPhone”，而不是“apple pie”。	表示基于深厚的专业知识的文本和上下文。例如，“apple”更接近“apple pie”，而不是“iPhone”。
单词联想	根据一般上下文形成关联。例如，“meat”、“sugar”和“dessert”同样相关。	根据特定领域的上下文形成关联。例如，“dessert”和“sugar”比“meat”和“sugar”更相关。
优点	用途广dessert泛，可以处理各种任务和查询。	由于有针对性的培训，在其特定领域具有高度准确和高效的能力。
局限性	可能在专业领域不具备深入的理解或生成准确的输出。	仅限于其特定领域，可能无法在该领域之外生成准确的输出。
用例	一般对话 AI、摘要、翻译和其他通用任务。	领域内高度专业化的任务（在本例中为食谱搜索和建议）。

重要的是要记住，虽然特定领域的LLM可以在其领域内提供更好的表现，但通用LLM更通用，可以处理更广泛的任务。两者之间的选择取决于应用程序的具体需求和目标。

使用特定领域的LLM有哪些好处？

在快速发展的人工智能领域，特定领域的语言模型已成为提高任务熟练程度和模型效率的关键工具。这些模型专为在特定领域表现出色而量身定制，利用大型语言模型的广泛知识库并对其进行微调，以在专业领域提供卓越的泛化能力和增强的可解释性。

以下是一些好处：

提高任务熟练度

大型语言模型根植于广泛的文本数据，展示了对语言的全面理解和丰富的常识，是特定领域微调的绝佳跳板。虽然LLM适合一般的语言任务，但它可能无法在医疗保健等专业领域发挥最佳作用。利用LLM作为基础模型并针对特定领域对其进行微调可以显着提高与任务相关的绩效。

提高效率

特定于领域的模型经过高度定制，可以执行一组特定的任务，并仅专注于与这些任务相关的信息。这种特殊性减少了计算开销和处理要求，从而提高了模型效率并加快了任务完成速度。

卓越的泛化能力

训练模型来理解特定语言和特定领域的知识，使它们能够更熟练地泛化到该领域内的新实例。当处理有限的数据集或该领域包含其自己独特的术语和概念时，这将成为一项至关重要的资产。这种能力在快速发展的领域尤其有利，例如医疗保健领域的精准医疗。

增强的可解释性

由于特定于任务的焦点和特定于领域的训练数据，特定领域模型的可解释性显着增强。无论任务是什么，无论是聊天、文本搜索、预测还是信息提取，这些模型都会产生更相关的结果，从而使它们更容易理解和更有意义。

构建特定领域的定制LLM的挑战

创建自定义大型语言模型给组织带来了各种挑战，大致分为数据、技术、道德和资源相关问题。

数据挑战

努力建立定制LLM的组织需要应对与数据相关的挑战，包括数据获取、质量和隐私。采购大量特定领域的数据可能要求很高，尤其是在处理专业或机密数据时。确保收集过程中的数据完整性至关重要，解决数据隐私和保护问题也至关重要，这需要部署有效的措施来匿名化数据并在整个培训和部署阶段保护数据。

技术挑战

定制LLM开发的技术障碍围绕模型架构、培训、评估和验证等方面。选择合适的架构和参数需要专业知识，而培训定制LLM则需要机器学习方面的高级能力。由于缺乏针对特定领域任务的既定基准，评估变得复杂，并且模型响应的准确性、安全性和合规性验证提出了额外的挑战。

道德挑战

在创建定制LLM时，必须面对与偏见、公平、内容审核和安全相关的道德问题。LLM可能会无意中纳入并延续培训数据中的偏见，因此需要进行细致的审核和缓解策略。必须建立强大的内容审核机制，以防止自定义LLM生成潜在的不当或有害内容。

资源挑战

定制LLM的开发提出了与资源相关的问题，主要是在计算资源和专业技能方面。培训LLM需要大量的计算资源，这对于某些组织来说可能非常昂贵且难以获得。它还需要一支精通机器学习、自然语言处理和软件工程的团队，这可能很难招募和保留，从而增加项目的复杂性和成本。

尽管存在固有的挑战，但它们并非不可克服。组织可以通过战略规划、适当的资源和专家指导成功开发和部署定制LLM，以满足其独特的需求。随着市场开始见证商业上可行的开源基础模型的出现，使用这些模型构建特定领域的LLM的趋势必将加剧。

在下面的部分中，我们将描述著名的 BloombergGPT 模型。通过提供 BloombergGPT 模型的概述，我们可以帮助您了解在使用基础模型开发您自己的特定领域的 LLM 时要采用的流程、技术和策略。

金融专业LLM BloombergGPT 的详细案例研究

Bloomberg 推出了 BloombergGPT，这是一种最先进的大型语言模型，它配备了广泛的金融数据，可在金融部门特定的 NLP 任务中实现卓越的性能。这个强大的人工智能工具可以加快财务数据的评估，协助风险评估，衡量财务情绪，并有可能实现会计和审计功能的自动化。

BloombergGPT 是为金融领域开发的高度专业化的语言模型。它是一个复杂的结构，配备了 500 亿个参数。该模型的训练使用了大量数据——来自彭博独特数据库的 3,630 亿个代币以及来自通用数据集的另外 3,450 亿个代币。金融和通用数据的结合产生了一个在其专业领域表现异常出色的模型。BloombergGPT 在处理财务任务时展示了对现有模型的重大改进。值得注意的是，尽管该模型具有专业性，但它在标准大型语言模型基准上仍保持着值得称赞的性能水平，证明了其多功能适用性。

据彭博社报道，金融行业错综复杂的性质需要专门针对金融数据进行训练的人工智能。在此背景下，BloombergGPT 旨在与 Bloomberg Terminal 进行交互，Bloomberg Terminal 是一个为金融专业人士提供实时市场数据、突发新闻、深入的金融研究和复杂分析的软件平台。

BloombergGPT 是在金融领域利用这项新技术的开创性进步。预计它将增强 Bloomberg 现有的 NLP 功能，包括情绪分析、命名实体识别、新闻分类和问答。此外，该模型能够构建彭博终端上可访问的海量数据，可以显着改善客户服务并释放人工智能在金融行业的巨大潜力。

彭博社的研究强调，虽然通用模型由于其广泛的功能而无需专门培训，但现有的特定领域模型的结果表明它们是不可替代的。尽管金融领域是彭博社的主要关注点，但该公司支持受益于通用模型的各种任务。因此，彭博社旨在构建像 BloombergGPT 这样的模型，该模型在通用 LLM 基准上表现出色，同时在财务任务上也表现出色。

BloombergGPT 是一种强大的大型语言模型 (LLM)，专门针对金融自然语言处理 (NLP) 任务进行了优化。这种优化是通过在训练阶段集成特定领域和通用数据来实现的。

Bloomberg 查询语言 (BQL) 作为一种复杂的查询语言，可在 Bloomberg 平台内访问和分析财务数据。BQL 虽然是一个强大的工具，但也很复杂，并且可以应用于多种任务，包括数据搜索、数据分析、报告生成和洞察推导。BloombergGPT 通过将自然语言查询转换为有效的 BQL 来简化这一过程，从而促进与财务数据更直观的交互。

此外，BloombergGPT 还拥有新闻设置的潜在应用，可作为建议新闻标题的工具。事实证明，此功能对于新闻应用程序很有价值，并可帮助记者策划新闻通讯。该模型接受段落作为输入，并提出适当的标题作为回报。此功能提高了新闻文章创建的便利性和速度，进一步增强了 BloombergGPT 在金融和新闻领域的实用性。

与 GPT-3 和其他LLM相比，BloombergGPT 在一般任务上表现出了有竞争力的表现，在一些特定于金融的任务上超过了他们。BloombergGPT 的推出代表了人工智能驱动的金融分析的重大突破，扩大了 NLP 在金融技术领域的应用范围。

BloombergGPT 可以执行哪些任务？

• 自然语言处理中的金融任务

当 BloombergGPT 处理 NLP 学科内的金融任务时，它的处理方式与一般 NLP 任务类似。然而，这些财务任务具有与一般任务不同的独特特征和挑战。这种动态的一个典型例子可以在情绪分析中看到。

情感分析是一种常见的 NLP 任务，旨在识别给定文本的语气或情感背景。以“公司将裁员 10,000 人”这样的标题为例。一般来说，这通常意味着负面情绪，因为它意味着许多人失业和潜在的困难。然而，当从金融背景的角度来看时，人们对这种情绪的看法可能会有所不同。

在金融领域，裁员通常表明公司正在提高运营效率。此举可以提高公司股价或增强投资者对公司的信心。正如 BloombergGPT 所理解和实施的那样，这清楚地表明了情感分析在金融领域应用时的多方面性质。

• 外部财务基准

在外部财务基准方面，BloombergGPT 利用了各种资源。这包括从 FLUE 基准测试以及 ConvFinQA 数据集提取的四个任务。大型语言模型在这些金融任务上的表现是一个相对未经探索的领域，使得评估变得复杂。

BloombergGPT 以独特的方式运作，在处理这些任务时采用少量学习方法。该技术涉及在少量示例或“镜头”上训练模型。此方法背后的目的是优化所有模型的平均性能。

这种方法展示了 BloombergGPT 如何应对在没有广泛共识或标准测试框架的情况下评估任务性能的挑战。尽管这些任务性质复杂，BloombergGPT 仍然致力于高效执行，并遵守其选择可最大化平均性能的镜头数量的主要原则。

• 内部任务：情感分析

在处理内部任务时，BloombergGPT 重点关注特定方面的情绪分析，这是金融文献中常见的做法。该过程涉及一种有条不紊的方法，围绕一个独特的发现阶段进行构建。

发现阶段有助于为情感分析奠定基础。它建立了注释和抽样程序，这是该过程的重要组成部分。此外，此阶段有助于衡量每个示例所需的注释器数量。

注释者的培训要求也在这个发现阶段确定。BloombergGPT 依靠这种结构化程序来保持一致且有效的情绪分析方法，确保结果准确且相关。这种方法强调了 BloombergGPT 勤奋、精确地执行复杂任务的承诺。

• 探索性任务：命名实体识别（NER）

命名实体识别（NER）是更广泛的自然语言处理领域中一项成熟的任务。然而，在生成语言学习模型方面，这一领域尚未得到深入研究。认识到 NER 在金融领域的相关性，BloombergGPT 开始了这项任务的探索之旅，旨在发现新的见解和方法。

BloombergGPT 背后的团队报告了他们对 NER 探索的初步结果。作为这项工作的一部分，他们利用了来自彭博内部资源各个领域的七个不同的 NER 数据集。

通过涉足生成LLM这个相对未知的领域，BloombergGPT 正在增强其能力，并为更广泛的自然语言处理领域贡献有价值的研究和发现。

• 标准通用 NLP 任务的评估

BloombergGPT 的性能在各种标准通用 NLP 任务上经过了严格的检验。该评估过程使用了 BIG-bench Hard，代表了更广泛的 BIG-bench 基准中最苛刻任务的子集。

尽管 BloombergGPT 的主要焦点显然是面向金融的任务，但在其学习过程中纳入通用训练数据被认为是至关重要的。这种方法基于这样一种可能性：此类综合数据可能会增强 BloombergGPT 的功效。这不仅可以增强其处理金融任务的能力，还可以提高其在传统 NLP 任务上的表现。

因此，尽管 BloombergGPT 从根本上以金融为重点，但它也重视全面的 NLP 能力的价值，积极寻求不仅在专业 NLP 任务上，而且在通用 NLP 任务上表现出色。

• 知识评估

研究团队对 BloombergGPT 的知识能力，特别是回忆训练阶段学到的信息的能力进行了仔细观察。该评估是通过各种场景进行的，在这些场景中，模型需要提供所提出问题的答案，而无需额外的上下文或资源的帮助。

这些场景包括多项选择题以及基于阅读理解的基准。因此，该评估的目的不仅是评估 BloombergGPT 在培训期间保留的事实知识，而且还评估其有效解释、理解和利用这些知识的能力。它为 BloombergGPT 的理解和回忆能力提供了宝贵的见解，这对于任何语言模型来说都是至关重要的方面，特别是在信息准确性和可靠性至关重要的金融领域。

• 语言任务

在 BloombergGPT 的评估中，某些任务并未直接与最终用户应用程序相关联。这些本质上是语言任务，旨在衡量模型在理解核心语言方面的熟练程度。

此类任务考察了 BloombergGPT 在消除歧义、解析语法和理解蕴涵方面的能力。这些领域是语言理解的基础，被选择来直接评估 BloombergGPT 的语言能力。通过检查这些能力，该团队旨在确保该模型能够熟练地应对语言复杂性，即使在金融语言处理的主要关注领域，这一技能也将被证明是无价的。

像 BloombergGPT 这样的特定领域 LLM 的架构

BloombergGPT的创建是Bloomberg机器学习（ML）产品和研究小组与 AI 工程团队的共同努力。他们的目标是编译迄今为止最大的特定领​​域数据集之一。这涉及利用彭博社庞大的数据创建、收集和管理资源。该团队利用彭博社广泛的金融数据档案，汇集了由英文金融文档组成的 3630 亿个代币的综合数据集。该语料库进一步扩充了包含 3450 亿个令牌的公共数据集，最终训练语料库的总数量超过了 7000 亿个令牌。

为了操作这个庞大的数据集，该团队选择训练一个包含 500 亿个参数的仅解码器因果语言模型。这种类型的模型擅长以顺序方式生成文本，使其成为处理自然语言数据的理想选择。然后，生成的模型在多个验证集上进行了测试：特定于金融的自然语言处理基准、彭博社的内部基准以及从广泛认可的基准中提取的各种通用 NLP 任务。

BloombergGPT 展示了卓越的性能，在金融特定任务上远远超过了同等规模的现有开源模型。重要的是，虽然其专业化并没有妨碍其处理更广泛任务的能力，但该模型也匹配或超过了一般 NLP 基准的性能。这凸显了 BloombergGPT 在增强金融 NLP 任务方面的潜力，同时又不牺牲其对于更通用应用的实用性。

BloombergGPT 的架构基于名为 BLOOM 的语言模型，该模型作为因果模型或“基于解码器”的模型运行。“因果”本质上意味着模型按顺序生成文本，根据前面的单词预测序列中的下一个单词。

BLOOM 模型的核心由 70 层 Transformer 解码器块组成。这是其含义的简单解释：

• Transformer 解码器块：它们是自然语言处理中使用的一种模型结构。它们旨在处理顺序数据，例如句子，其中元素的顺序很重要。Transformer 解码器块使用以下组件：
  • SA（自注意力）：这种机制帮助模型在生成输出时对输入中的不同单词给予不同程度的“注意力”。它使模型能够专注于重要的单词并更好地理解上下文。
  • LN（层标准化）：这是一种稳定和加速模型学习过程的技术。它确保模型执行的计算保持在可管理的范围内，防止出现数值问题。
  • FFN（前馈网络）：这是一种人工神经网络，信息从输入到输出朝一个方向移动。它没有任何循环或循环，每一层神经元都完全连接到下一层。

该模型还将输入标记嵌入（单词的数字表示）与最终输出确定之前发生的线性映射联系起来。这一步有助于降低模型的复杂度，并且可以提高模型学习过程的效率。

最后，在令牌嵌入之后添加了一个额外的层标准化步骤。在这种情况下，初始令牌嵌入以及嵌入的层归一化的附加组件。包含两个连续层归一化步骤可确保模型的稳定性并有助于高效学习。

总之，BloombergGPT 模型的架构旨在高效地学习和生成文本数据，并具有多个旨在增强模型稳定性和学习速度的功能。

BloombergGPT 是如何训练的？

第 1 步：构建 FinPile 数据集

负责创建 BloombergGPT 的研究团队在训练过程中使用了名为“FinPile”的广泛且多样化的数据集。FinPile 包含来自多个来源的各种英文财务文件，即新闻文章、文件、新闻稿和社交媒体内容，所有这些都来自广泛的彭博档案。

这些丰富的财务数据包括公司备案、财务新闻以及与市场趋势相关的其他信息等元素。其中一些数据可以公开访问，而其他部分只能通过购买或通过彭博终端进行独家访问来访问。这些数据经过精心清理，以删除任何不必要的元素，例如标记、特殊格式和模板。此外，每个文件都带有时间戳，时间跨度从2007年3月1日到2022年7月31日，这表明数据质量和数量随着时间的推移逐渐提高。

虽然该团队无法发布 FinPile 数据集，但他们的目标是分享构建这个高度特定领域模型的见解和经验。他们还打算在未来的研究工作中利用日期信息。

FinPile 的财务数据与 LLM 培训常用的公共数据配对，创建一个平衡的培训语料库，对特定领域和通用文本具有相同的表示。该团队对每个数据集进行了重复数据删除过程，以保持较高的数据质量，这可能会导致统计报告与其他研究不同。

第 2 步：Tokenization

BloombergGPT 背后的研究团队决定使用 Unigram 分词器，而不是其他基于贪婪合并的子词分词器（如 BPE 或 Wordpiece）。这一决定是基于 Unigram 分词器在先前研究中的良好表现。他们采用基于字节的数据处理方法，而不是更常见的将数据视为 Unicode 字符序列的做法。

此外，该团队还采用了与 GPT-2 中使用的类似的预标记化过程，该过程将输入分解为不同的块。该方法有利于多词标记的学习，从而增加信息密度并减少上下文长度。

该团队使用 Pile 数据集来训练他们的标记器。鉴于其多样化的内容，The Pile 被认为是适合他们目的的选择。处理如此大的数据集需要并行分词器训练方法，团队为此采用了拆分和合并策略。他们对每个数据块训练了一个 Unigram 分词器，然后以分层方式合并它们以创建最终的分词器。

生成的标记生成器由 700 万个标记组成，进一步压缩为 131,072 个标记。词汇量大小的决定受到多种因素的影响，包括需要将更多信息放入上下文窗口以及与开销相关的考虑因素。在使用不同词汇量和 C4 数据集的最小编码表示进行实验后，团队得出了 131,072 个标记的词汇量。因此，BloombergGPT 使用的标记生成器相对大于大约 50,000 个标记的标准词汇量。

第 3 步：构建模型

Bloomberg 团队在 BLOOM 模型提供的结构基础上构建 BloombergGPT 模型。这涉及利用包含 70 层 Transformer 解码器块的仅解码器因果语言模型。这些模块由多头自注意力、层归一化和具有单个隐藏层的前馈网络组成。GELU 函数被用作网络内的非线性元素。

此外，还实现了 ALiBi 位置编码或带有线性偏差的注意力，并且输入标记嵌入连接到最终 softmax 应用之前的线性映射。在令牌嵌入之后执行附加层归一化。

利用 Chinchilla 的缩放定律，Bloomberg 团队确定 BloombergGPT 模型的大小。他们将 40GB A100 GPU 上的总计算预算设置为 130 万个 GPU 小时。考虑了与激活检查点相关的成本，并使用 Chinchilla 方程来确定参数和令牌数量之间的最佳平衡。

尽管拥有大约 7000 亿个代币的重要数据集，但彭博团队发现，鉴于其计算预算，对于最佳配置而言，该数据集过于有限。为了规避这一限制，他们选择了尽可能最大的模型，拥有 500 亿个参数，同时保留总计算预算的约 30%，作为应对可能出现的潜在挑战的保障。

为了设置拥有 500 亿个参数的 BloombergGPT 模型的结构，Bloomberg 团队使用了 Levine 等人的建议。（2020）。根据这些建议，隐藏层的理想大小 (D) 取决于模型的自注意力层数量 (L)。该团队选择了 70 个自注意力层（L = 70），隐藏层的目标大小为 7510（D = 7510）。

为了增强模型 Tensor Core 运算的性能，团队采用了 40 个头的设计，每个头的维度为 192。这导致总隐藏大小 (D) 为 7680，使总体参数数达到 506 亿。

第 4 步：训练模型

BloombergGPT 模型基于 PyTorch 构建，按照标准因果语言建模目标进行训练，方向性从左到右。该团队战略性地将训练序列的长度设置为 2,048 个令牌，以充分利用 GPU 资源。

优化过程中使用了 AdamW 优化器，学习率与包括线性预热的余弦衰减时间表一致。此外，还应用批量大小预热来增强性能。

该模型的训练和评估阶段在 Amazon SageMaker 上进行，利用 64 个 p4d.24xlarge 实例，每个实例配备 8 个 NVIDIA 40GB A100 GPU。为了确保高效的数据访问和高速吞吐量，该团队采用 Amazon FSX for Lustre，它支持存储单元每 TiB 的读写操作高达 1000 MB/s。

第 5 步：大规模优化

为了在 GPU 内存的限制下训练实质性 BloombergGPT 模型，Bloomberg 团队实施了一系列优化技术：

• ZeRO 优化（第 3 阶段）：这种方法涉及将训练状态划分到一组 GPU 上。以 BloombergGPT 为例，团队部署了 128 个 GPU 来进行分片，并在整个训练过程中维护模型的四个副本。
• MiCS：该系统旨在降低云中训练集群的通信开销和内存需求。它利用分层通信、2 跳梯度更新机制和尺度感知模型划分方案。
• 激活检查点：此技术会在向后传递期间丢弃激活并重新计算中间张量，以便在必要时最大限度地减少训练过程中消耗的内存。
• 混合精度训练：此策略通过以 BFloat16 精度执行前向和后向传递，同时以全精度 (FP32) 存储和更新参数，有助于节省内存。
• 融合内核：此方法将多个操作合并为单个 GPU 操作。由于避免了中间结果的存储和速度的提高，结果是减少了峰值内存使用量。

通过应用这些优化，Bloomberg 团队成功实现了 102 TFLOP 的平均计算性能，每个训练步骤大约需要 32.5 秒。

BloombergGPT 如何处理道德和隐私问题？

BloombergGPT 专为金融应用程序而设计，其开发完全注重道德和隐私考虑。这些方面在开发过程中通过一系列精心设计的措施得到了精心解决。

• 风险评估和合规程序

认识到金融行业的敏感性，彭博建立了健全的风险评估和测试流程。准确性和事实信息被认为对于公司的声誉和客户的满意度至关重要，客户越来越多地寻求将先进技术融入其运营中。

该过程涉及严格的注释指南、涉及中央风险和合规部门的多级发布前审查以及持续的发布后监控。BloombergGPT 的所有研究、开发和部署程序均符合相关法规，保持高合规标准。

• 毒性和偏差控制

彭博社付出了非凡的努力来控制由人类或人工智能模型产生的内容中任何潜在的毒性和偏见。BloombergGPT 背后的团队一直对评估和量化各种应用程序环境中有害语言的潜在生成保持着兴趣。我们特别关注研究 FinPile 语料库对模型倾向的影响，该语料库的特点是偏见或有毒语言的发生率较低。随着 BloombergGPT 集成到新产品中，将应用这些严格的测试程序和合规控制来确保安全使用。

• 模型发布和开放

如何颁发LLM的问题是人工智能界持续争论的话题。考虑到LLM可能被滥用，尤其是像 BloombergGPT 这样接受过大量敏感数据培训的LLM，彭博社采用了战略方法来解决这个问题。我们考虑了各种策略，从在特定使用许可下发布经过训练的模型，到在不泄露底层模型参数或详细训练数据的情况下授予 API 访问权限。

鉴于数据泄露攻击的巨大风险，彭博社选择了保守的做法，不公开 BloombergGPT 模型参数。这一决定符合公司的使命，即提供数十年来收集的数据的访问权限，同时确保其免受潜在的滥用。

• 对领域的贡献

尽管没有发布该模型，但 BloombergGPT 的开发历程为更广泛的 NLP 社区，特别是那些创建特定领域模型的社区提供了宝贵的见解。在训练和评估 BloombergGPT 中获得的经验可以帮助更好地理解这些模型，为 NLP 和 LLM 领域的共享知识做出贡献。彭博社承认各种其他模型和项目对 BloombergGPT 发展的影响，并继续努力为这种集体智慧做出贡献。

如何将开源基础模型训练成特定领域的LLM？

这里的目标是开发一个利用 BERT（一种预训练的大型语言模型）强大功能的分类模型。为了定制该模型以适应特定领域，将使用特定领域的数据（特别是来自社交媒体领域的有毒评论分类挑战数据）对其进行微调。

Kaggle上提供了执行该项目所必需的数据集。对于这种特殊情况，仅使用可用数据集中的“train.csv”文件。

让我们编码吧！

第1步：加载数据集

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import transformers
from transformers import AutoModel, BertTokenizerFast

# 如果您有 GPU，请指定 GPU
device = torch.device("cuda")

# ---------------------------------------------------------------------------------

# 潜在客户数据集
df = pd.read_csv("train.csv")
# mydata.csv has only 2 columns "text" and "label" (binary)
df = df.sample(6400)[['comment_text', 'toxic']]
df.columns = ['text', 'label']

# 打印数据并查看
df.head()

# 检查类别分布
print(df['label'].value_counts(normalize=True))

# 将数据分为训练和测试
train_text, temp_text, train_labels, temp_labels = train_test_split(
df['text'],
df['label'],
random_state=1234,
test_size=0.3,
stratify=df['label'])

# 使用上一步中创建的 temp_text 和 temp_labels 生成验证集和测试集
val_text, test_text, val_labels, test_labels = train_test_split(
temp_text,
temp_labels,
random_state=1234,
test_size=0.5,
stratify=temp_labels)
# 这将产生 70% 的训练数据、15% 的验证和 15% 的测试

第 2 步： Tokenizaton

# 从预保留模型导入 BERT 分词器
bert = AutoModel.from_pretrained('bert-base-uncased')
tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')

# 获取数据中所有句子的长度
seq_len = [len(i.split()) for i in train_text]
pd.Series(seq_len).hist(bins=100)

# 根据上面的分布选择我们将保留的 max_seq_len - 目标文本的 85-90%
max_seq_len = 100

# 在训练、验证和测试集中按照上面确定的最大长度修剪序列
# 对序列进行标记和编码
tokens_train = tokenizer.batch_encode_plus(train_text.tolist(),
max_length=max_seq_len,
pad_to_max_length=True,
truncation=True,
return_token_type_ids=False)

tokens_val = tokenizer.batch_encode_plus(val_text.tolist(),
max_length=max_seq_len,
pad_to_max_length=True,
truncation=True,
return_token_type_ids=False)

tokens_test = tokenizer.batch_encode_plus(test_text.tolist(),
max_length=max_seq_len,
pad_to_max_length=True,
truncation=True,
return_token_type_ids=False)

# 将 token 转换为张量以用于训练、验证和测试
train_seq = torch.tensor(tokens_train['input_ids'])
train_mask = torch.tensor(tokens_train['attention_mask'])
train_y = torch.tensor(train_labels.tolist())

val_seq = torch.tensor(tokens_val['input_ids'])
val_mask = torch.tensor(tokens_val['attention_mask'])
val_y = torch.tensor(val_labels.tolist())

test_seq = torch.tensor(tokens_test['input_ids'])
test_mask = torch.tensor(tokens_test['attention_mask'])
test_y = torch.tensor(test_labels.tolist())

第 3 步：创建数据加载器以准备训练数据

from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler


# 定义批量大小（您可能需要根据样本大小调整批量大小）
batch_size = 32

# 包装张量、随机采样器和训练数据的准备数据加载器
train_data = TensorDataset(train_seq, train_mask, train_y)
train_sampler = RandomSampler(train_data)
train_dataloader = DataLoader(train_data,
sampler=train_sampler,
batch_size=batch_size)

# 包装张量、随机采样器和准备数据加载器以获取验证数据
val_data = TensorDataset(val_seq, val_mask, val_y)
val_sampler = SequentialSampler(val_data)
val_dataloader = DataLoader(val_data,
sampler=val_sampler,
batch_size=batch_size)

# 通过设置requires_grad = False来冻结所有参数
for param in bert.parameters():
    param.requires_grad = False

第 4 步：定义模型架构：向神经网络添加 3 个层和 1 个二进制输出层

class BERT_Architecture(nn.Module):

    def __init__(self, bert):

        super(BERT_Arch, self).__init__()

        self.bert = bert
        # dropout layer
        self.dropout = nn.Dropout(0.1)
        # relu activation function
        self.relu = nn.ReLU()
        # dense layer 1 # Note 768 is immutable for BERT, you can choose a dimension for the fc2 layer
        self.fc1 = nn.Linear(768, 512)
        # dense layer 2 (Output layer)
        self.fc2 = nn.Linear(512, 128)
        # dense layer 3 (Output layer)
        self.fc3 = nn.Linear(128, 32)
        # dense layer 4 (Output layer)
        self.fc4 = nn.Linear(32, 2)
        #softmax activation function
        self.softmax = nn.LogSoftmax(dim=1)

    #define the forward pass
    def forward(self, sent_id, mask):

        #pass the inputs to the model
        _, cls_hs = self.bert(sent_id, attention_mask=mask, return_dict=False)       
        # Execute 1st layer 
        x = self.fc1(cls_hs)
        x = self.relu(x)
        x = self.dropout(x)
        
        # Execute 2nd layer 
        x = self.fc2(x)
        x = self.relu(x)
        x = self.dropout(x)
        
        # Execute 3rd layer 
        x = self.fc3(x)
        x = self.relu(x)
        x = self.dropout(x)

        # output layer
        x = self.fc4(x)

        # apply softmax activation
        x = self.softmax(x)

        return x

第 5 步：通过预训练的BERT来准备损失函数

# pass the pre-trained BERT to our define architecture
model = BERT_Architecture(bert)

# 将模型推送到GPU
model = model.to(device)

# 拥抱脸部Transformer的优化器
from transformers import AdamW

# 定义优化器
optimizer = AdamW(model.parameters(), lr=1e-3)

# 找到类别权重并将其推送到 GPU
from sklearn.utils.class_weight import compute_class_weight

class_weights = compute_class_weight(class_weight="balanced",
                                     classes=np.unique(train_labels),
                                     y=train_labels)
# class_weights = dict(zip(np.unique(train_labels), class_weights))
# 将类权重转换为张量
weights = torch.tensor(class_weights, dtype=torch.float)
weights = weights.to(device)

# 定义预训练损失函数
cross_entropy = nn.NLLLoss(weight=weights)

# 训练纪元数
epochs = 100
print(class_weights)

第 6 步：训练模型

# 定义训练函数
def train():
    # 训练模型
    model.train()

    # 一开始将损失和准确度设置为零（它将随着时间的推移而更新）
    total_loss, total_accuracy = 0, 0

    # 保存模型预测的空列表
    total_preds = []

    # 迭代批次
    for step, batch in enumerate(train_dataloader):

        # 将批处理推送到 GPU
        batch = [r.to(device) for r in batch]
        sent_id, mask, labels = batch

        # 清除之前计算的梯度
        model.zero_grad()

        #  获取当前批次的模型预测
        preds = model(sent_id, mask)

        # 计算实际值和预测值之间的损失
        loss = cross_entropy(preds, labels)

        # 添加到总损失中
        total_loss = total_loss + loss.item()

        # 向后传递计算梯度
        loss.backward()

        # 将渐变剪裁为 1.0。它有助于防止梯度爆炸问题
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)

        # 更新参数
        optimizer.step()

        # 模型预测存储在 GPU 上。所以，将其推送到CPU
        preds = preds.detach().cpu().numpy()

        # 附加模型预测
        total_preds.append(preds)

    # 计算该纪元的训练损失
    avg_loss = total_loss / len(train_dataloader)

    # 预测的形式为（批次数量、批次大小、类数量）。
    # 我们必须以（样本数，类数）的形式重塑预测
    total_preds = np.concatenate(total_preds, axis=0)

    # 返回损失和预测
    return avg_loss, total_preds

第 7 步：评估模型

# 定义验证函数
def evaluate():

    print("\nEvaluating...")

    # 停用 dropout 层
    model.eval()

    # 再次将损失和准确度设置为零
    total_loss, total_accuracy = 0, 0

    # 空列表来保存模型预测
    total_preds = []

    # 迭代批次
    for step, batch in enumerate(val_dataloader):

        # 将批处理推送到 GPU
        batch = [t.to(device) for t in batch]
        sent_id, mask, labels = batch

        # 停用自动分级
        with torch.no_grad():
            # 模型预测
            preds = model(sent_id, mask)

            # 计算实际值和预测值之间的验证损失
            loss = cross_entropy(preds, labels)
            total_loss = total_loss + loss.item()
            preds = preds.detach().cpu().numpy()
            total_preds.append(preds)

    # 计算该纪元的验证损失
    avg_loss = total_loss / len(val_dataloader)

    # 以（样本数，类数）的形式重塑预测
    total_preds = np.concatenate(total_preds, axis=0)

    return avg_loss, total_preds

第 8 步：运行管道以迭代训练和评估模型并获取每个 epoch 的输出

# 现在让我们运行管道来迭代地训练和评估模型，并获得每个历元的输出

# 将初始损失设置为无限
best_valid_loss = float('inf')

# 空列表来存储每个时期的训练和验证损失
train_losses = []
valid_losses = []

# 对于每一轮
for epoch in range(epochs):

    # 训练模型
    train_loss, _ = train()

    # 验证模型
    valid_loss, _ = evaluate()

    # 保存最佳模型
    if valid_loss < best_valid_loss:
        best_valid_loss = valid_loss
        torch.save(model.state_dict(), 'saved_weights.pt')

    # 附加训练和验证损失
    train_losses.append(train_loss)
    valid_losses.append(valid_loss)

    print(
        f'Epoch {epoch + 1}/{epochs}\tTraining Loss: {train_loss:.3f}\tValidation Loss: {valid_loss:.3f}'
    )

# 最佳模型的负载权重
path = 'saved_weights.pt'
model.load_state_dict(torch.load(path))

# 获取测试数据的预测
with torch.no_grad():
    preds = model(test_seq.to(device), test_mask.to(device))
    preds = preds.detach().cpu().numpy()

# 模型的性能
preds = np.argmax(preds, axis=1)
print(classification_report(test_y, preds))
pd.crosstab(test_y, preds)

总结

正如我们得出的结论，很明显，特定领域的大型语言模型不仅有益，而且对于现代组织来说确实是必要的。从通用模型到更定制的语言处理模型的转变满足了独特的行业需求，增强了性能，实现了个性化交互并简化了操作。此外，这些定制模型提供了改进的数据隐私控制和财务效率。

在快速发展的人工智能和自然语言处理领域，采用特定领域的LLM代表着保持竞争力和创新的关键一步。这些模型经过微调以了解特定的行业语言和背景，改变组织与数据和数字接口交互的方式。对特定领域LLM的需求是不可否认的，现在的问题是组织能够以多快的速度适应这一强大的工具并将其集成到他们的流程中以释放其全部潜力。