OpenAI 推出强大的生成式预训练转换器 （GPT） 语言模型，为自然语言处理 （NLP） 开辟了新的领域。将 GPT 模型集成到虚拟助手和聊天机器人中可以增强它们的能力，这导致对 GPT 模型的需求激增。根据 Allied Market Research 发布的一份题为“全球 NLP 市场”的报告，2020 年全球 NLP 市场规模为 111 亿美元，预计到 2030 年将达到 3415 亿美元，2021 年至 2030 年的复合年增长率为 40.9%。有趣的是，对 GPT 模型的需求是这一增长的主要贡献者。

GPT 模型是由 OpenAI 团队创建的基于深度学习的语言模型的集合。在没有监督的情况下，这些模型可以执行各种 NLP 任务，如问答、文本蕴涵、文本摘要等。这些语言模型需要很少或不需要示例来理解任务。它们的性能与以监督方式训练的最先进模型相当，甚至更好。

OpenAI 的 GPT 系列从根本上改变了人工智能的格局。该系列的最新成员 GPT-4 进一步扩大了 AI 应用的视野。本文将带您踏上 GPT-4 创新领域的旅程。我们将深入研究其 GPT 模型的显着进步，同时探索这种最先进的模型如何重塑我们与不同领域的 AI 互动。

本文深入探讨了 GPT 模型的各个方面，并讨论了从头开始构建 GPT 模型所需的步骤。

目录

什么是GPT模型？

GPT 模型概述

GPT模型的用例

使用 NLP 理解人类语言

为用户界面设计生成内容

在计算机视觉系统中的图像识别应用

通过人工智能聊天机器人增强客户支持

通过准确的翻译弥合语言障碍

简化代码生成

通过个性化辅导改变教育

协助创意写作

GPT模型的工作机制

如何选择适合您需求的 GPT 模型？

构建 GPT 模型的先决条件

你的 AI 了吗？让我们合作吧。

如何创建GPT模型？分步指南

导入库

定义超参数

读取输入文件

识别文本中出现的唯一字符

创建映射

对输入数据进行编码

将数据拆分为训练集和验证集

生成用于训练 GPT 的批量输入和目标数据

使用预训练模型计算训练和验证数据集的平均损失

在Transformers模型中定义自注意力机制的一个头

实现多头注意力机制

接下来我们需要添加 FeedFoward 模块

模型训练和文本生成

如何使用您的数据训练现有的 GPT 模型？

先决条件

设置主机

闪光关注

容器化设置

用法

配置

数据准备

训练和微调

构建 GPT 模型时要考虑的事项

消除偏见和毒性

改善幻觉

防止数据泄露

合并查询和操作

结尾

什么是GPT模型？

GPT 代表 Generative Pre-trained Transformer，这是 NLP 中的第一个通用语言模型。以前，语言模型仅针对文本生成、摘要或分类等单个任务而设计。GPT 是自然语言处理史上第一个通用语言模型，可用于各种 NLP 任务。现在让我们探讨一下 GPT 的三个组成部分，即生成、预训练和转换器，并了解它们的含义。

生成：生成模型是用于生成新数据的统计模型。这些模型可以学习数据集中变量之间的关系，以生成与原始数据集中的数据点类似的新数据点。

预训练：这些模型已经使用大型数据集进行了预训练，当难以训练新模型时可以使用该数据集。尽管预训练模型可能并不完美，但它可以节省时间并提高性能。

Transformer：Transformer 模型是 2017 年创建的人工神经网络，是能够处理文本等顺序数据的最著名的深度学习模型。机器翻译和文本分类等许多任务都是使用 Transformer 模型执行的。

GPT 可以高精度地执行各种 NLP 任务，具体取决于它所训练的大型数据集及其数十亿参数的架构，使其能够理解数据中的逻辑连接。GPT 模型与最新版本的 GPT-3 一样，已经使用来自五个大型数据集的文本进行了预训练，包括 Common Crawl 和 WebText2。该语料库包含近一万亿个单词，允许 GPT-3 快速执行 NLP 任务，而无需任何数据示例。

GPT 模型概述

GPT 模型是 Generative Pretrained Transformer 的缩写，是高级深度学习模型，旨在生成类似人类的文本。这些由 OpenAI 开发的模型已经经历了几次迭代：GPT-1、GPT-2、GPT-3，以及最近的 GPT-4。

GPT-1 于 2018 年推出，是该系列中的第一款，它使用独特的 Transformer 架构极大地提高了语言生成能力。它由 1.17 亿个参数构建，并在 Common Crawl 和 BookCorpus 的数据集上进行了训练。GPT-1 可以在给定的上下文中生成流畅且连贯的语言。然而，它也有局限性，包括倾向于重复文本，以及复杂对话和长期依赖的困难。

OpenAI 随后在 2019 年发布了 GPT-2。这个模型要大得多，有 15 亿个参数，并且在更大、更多样化的数据集上进行训练。它的主要优势是能够生成逼真的文本序列和类似人类的响应。然而，GPT-2 在较长的段落中难以保持上下文和连贯性。

2020 年 GPT-3 的推出标志着一个巨大的飞跃。GPT-3 拥有惊人的 1750 亿个参数，在庞大的数据集上进行了训练，可以在各种任务中产生细微的响应。它可以生成文本、编写代码、创作艺术等，使其成为聊天机器人和语言翻译等许多应用程序的宝贵工具。然而，GPT-3 并不完美，并且存在偏见和不准确之处。

继 GPT-3 之后，OpenAI 推出了升级版 GPT-3.5，并最终于 2023 年 3 月发布了 GPT-4。GPT-4 是 OpenAI 最新、最先进的多模态语言模型。它可以生成更准确的语句并将图像作为输入进行处理，从而允许标题、分类和分析。GPT-4 还展示了创作歌曲或编写剧本等创作能力。它有两种变体，它们的上下文窗口大小不同：gpt-4-8K 和 gpt-4-32K。

GPT-4 能够理解复杂的提示并在各种任务中展示类似人类的表现，这是一个重大的飞跃。然而，与所有强大的工具一样，人们对潜在的滥用和道德影响存在合理的担忧。在探索 GPT 模型的功能和应用时，牢记这些因素至关重要。

GPT模型的用例

GPT 模型以其多功能应用而闻名，在各个领域提供了巨大的价值。在这里，我们将讨论三个关键用例：理解人类语言、UI 设计的内容生成和自然语言处理中的应用。

使用 NLP 理解人类语言

GPT 模型有助于增强计算机理解和处理人类语言的能力。这包括两个主要方面：

• 人类语言理解 （HLU）：HLU是指机器理解句子和短语含义的能力，有效地将人类知识翻译成机器可读的格式。这是使用深度神经网络或前馈神经网络实现的，涉及统计、概率、决策树、模糊集和强化学习技术的复杂组合。在这一领域开发模型具有挑战性，需要大量的专业知识、时间和资源。
• 自然语言处理 （NLP）：NLP专注于解释和分析书面或口头的人类语言。它涉及训练计算机理解语言，而不是使用预先设定的规则或指令对它们进行编程。NLP 的主要应用包括信息检索、分类、汇总、情感分析、文档生成和问答。它还在数据挖掘、情感分析和计算任务中发挥着关键作用。

为用户界面设计生成内容

GPT 模型可用于生成用户界面设计的内容。例如，它们可以帮助创建网页，用户只需点击几下即可上传各种形式的内容。这包括添加标题、标题、描述和 alt 标签等基本元素，以及合并按钮、测验和卡片等交互式组件。这种自动化减少了对额外开发资源和投资的需求。

在计算机视觉系统中的图像识别应用

GPT 模型不仅限于处理文本。当与计算机视觉系统结合使用时，它们可以执行图像识别等任务。这些系统可以识别和记住图像中的特定元素，如人脸、颜色和地标。GPT-3 凭借其 Transformer 架构，可以有效地处理此类任务。

通过人工智能聊天机器人增强客户支持

GPT 模型通过为 AI 聊天机器人提供动力，正在彻底改变客户支持。这些配备 GPT-4 的聊天机器人可以更精确地理解和响应客户查询。它们可以模拟类似人类的对话，提供详细的响应，并全天候提供即时支持。这通过提供快速、准确的响应来显着增强客户服务，从而提高客户满意度和忠诚度。

通过准确的翻译弥合语言障碍

语言翻译是 GPT-4 擅长的另一个领域。其先进的语言理解功能使其能够准确地翻译各种语言之间的文本。GPT-4 可以掌握不同语言的细微差别，并提供保留原始含义和上下文的翻译。此功能在促进跨文化交流和使全球受众可以访问信息方面非常有用。

简化代码生成

GPT-4 理解和生成编程语言代码的能力使其成为开发人员的宝贵工具。它可以根据开发人员的输入生成代码片段，从而显着加快编码过程并减少出错的机会。通过了解不同编程语言的上下文和细微差别，GPT-4 可以协助完成更复杂的编码任务，从而有助于更高效、更简化的软件开发。

通过个性化辅导改变教育

教育部门可以从 GPT-4 的实施中受益匪浅。它可以生成适合学习者需求的教育内容，提供个性化的辅导和学习帮助。从以简单的方式解释复杂的概念到为家庭作业提供支持，GPT-4 可以使学习更具吸引力和可访问性。它能够适应不同的学习风格和节奏，有助于提供更加个性化和有效的学习体验。

协助创意写作

在创意写作领域，GPT-4 可以成为宝贵的助手。它可以为作家提供创造性的建议，帮助克服作家的障碍，甚至生成整个故事或诗歌。通过了解背景并保持叙事的流畅性，GPT-4 可以制作出连贯且引人入胜的创意作品。对于作家来说，这可能是一个有价值的工具，可以激发创造力，提高生产力。

GPT模型的工作机制

GPT 是一种基于 Transformer 架构的 AI 语言模型，它是预训练的、生成式的、无监督的，能够在零/一/少镜头多任务设置中表现良好。它从 NLP 任务的一系列标记中预测下一个标记（字符序列的实例），它尚未经过训练。在只看到几个例子之后，它可以在某些基准测试中实现预期的结果，包括机器翻译、问答和完形填空任务。GPT 模型计算一个单词出现在文本中的可能性，因为它主要基于条件概率出现在另一个文本中。例如，在句子中，“玛格丽特正在组织车库销售......也许我们可以买那个旧的......”“椅子”这个词比“大象”这个词更合适。此外，转换器模型使用多个称为注意力块的单元，这些单元学习要关注文本序列的哪些部分。一个转换器可能有多个注意力块，每个注意力块学习语言的不同方面。

transformer有两个主要部分：一个编码器主要对输入序列进行操作，解码器在训练期间对目标序列进行操作并预测下一个项目。例如，转换器可能会采用一系列英语单词，并预测正确翻译中的法语单词，直到它完成。

编码器确定应强调输入的哪些部分。例如，编码器可以读取类似“快速的棕色狐狸跳跃”之类的句子。然后，它计算嵌入矩阵（NLP中的嵌入允许具有相似含义的单词具有相似的表示形式）并将其转换为一系列注意力向量。现在，什么是注意力向量？您可以将 transformer 模型中的注意向量视为一个特殊的计算器，这有助于模型了解任何给定信息的哪些部分在做出决策时最重要。假设您在考试中被问到多个问题，您必须使用不同的信息片段来回答这些问题。注意力向量可帮助您选择最重要的信息来回答每个问题。它的工作方式与Transformers模型相同。

多头注意力块最初会产生这些注意力向量。然后，它们被归一化并传递到一个完全连接的层中。在传递到解码器之前，再次进行规范化。在训练过程中，编码器直接在目标输出序列上工作。假设目标输出是英语句子“The quick brown fox jumped”的法语翻译。解码器为句子的每个法语单词计算单独的嵌入向量。此外，位置编码器以正弦和余弦函数的形式应用。此外，还使用了掩蔽的注意力，这意味着使用法语句子的第一个单词，而所有其他单词都被掩蔽。这允许转换器学习预测下一个法语单词。然后，这些输出被添加并归一化，然后传递到另一个注意力块，该注意力块也接收编码器生成的注意力向量。

此外，GPT 模型采用一些数据压缩，同时消耗数百万个示例文本将单词转换为向量，这些向量只不过是数字表示。然后，语言模型将压缩文本解压缩为人类友好的句子。通过压缩和解压缩文本，可以提高模型的准确性。这也允许它计算每个单词的条件概率。GPT 模型可以在“几张照片”设置中表现良好，并响应以前见过的文本样本。它们只需要几个示例即可产生相关的响应，因为它们已经在许多文本样本上进行了训练。

此外，GPT 模型具有许多功能，例如生成前所未有的质量合成文本样本。如果使用输入启动模型，它将生成一个长延续。GPT 模型优于在维基百科、新闻和书籍等领域训练的其他语言模型，而无需使用特定领域的训练数据。GPT 仅从文本中学习语言任务，例如阅读理解、总结和问答，而无需特定于任务的训练数据。这些任务的分数（“分数”是指模型分配的数值，用于表示给定输出或结果的可能性或概率）不是最好的，但它们表明具有足够数据和计算的无监督技术可以使任务受益。

以下是 GPT 模型与其他语言模型的全面比较。

如何选择适合您需求的 GPT 模型？

为您的项目选择正确的 GPT 模型取决于几个因素，包括您希望模型处理的任务的复杂性、您想要生成的语言类型以及可用数据集的大小。

如果您需要一个可以生成简单文本响应的模型，例如回复客户查询，GPT-1 可能是一个足够的选择。它能够完成简单的任务，而无需大量的数据或计算资源。

但是，如果您的项目涉及更复杂的语言生成，例如对大量网络内容进行深入分析、推荐阅读材料或生成故事，那么 GPT-3 将是更合适的选择。GPT-3 能够处理和学习数十亿个网页，提供更细致、更复杂的输出。

就数据要求而言，可用数据集的大小应该是一个关键考虑因素。GPT-3 具有更大的学习能力，往往最适合处理大型数据集。如果您没有大量可用于训练的数据，GPT-3 可能不是最有效的选择。

相比之下，GPT-1 和 GPT-2 是更易于管理的模型，可以使用较小的数据集进行有效训练。这些版本可能更适合数据资源有限的项目或小规模任务。

展望未来，有 GPT-4。虽然有关其特定功能和要求的详细信息尚未广泛提供，但这种较新的迭代可能会提供增强的性能，并且可能需要更大的数据集和更多的计算资源。在为您的项目选择合适的 GPT 模型时，请始终考虑任务的复杂性、资源可用性以及每个 GPT 模型提供的具体好处。

构建 GPT 模型的先决条件

要构建 GPT（生成式预训练转换器）模型，需要以下工具和资源：

• 深度学习框架，例如 TensorFlow 或 PyTorch，用于实现模型并在大量数据上对其进行训练。
• 大量训练数据，例如来自书籍、文章或网站的文本，用于在语言模式和结构上训练模型。
• 高性能计算环境，例如 GPU 或 TPU，用于加速训练过程。
• 了解深度学习概念，例如神经网络和自然语言处理 （NLP），以设计和实现模型。
• 用于数据预处理和清理的工具，例如 Numpy、Pandas 或 NLTK，用于准备训练数据以输入到模型中。
• 用于评估模型的工具，例如困惑度或 BLEU 分数，以衡量其性能并进行改进。
• 一个 NLP 库，例如 spaCy 或 NLTK，用于对输入数据进行标记化、词干提取和执行其他 NLP 任务。

此外，您需要了解以下深度学习概念来构建 GPT 模型：

• Neural networks：当 GPT 模型实现神经网络时，您必须彻底了解它们在深度学习框架中的工作原理及其实现技术。
• 自然语言处理 （NLP）：对于 GPT 建模过程、标记化、词干提取和文本生成，NLP 技术被广泛使用。因此，有必要对NLP技术及其应用有一个基本的了解。
• Transformers：GPT 模型基于 transformer 架构工作，因此了解它及其在语言处理和生成中的作用非常重要。
• 注意机制：了解注意力机制的工作原理对于提高 GPT 模型的性能至关重要。
• 预训练：必须将预训练的概念应用于 GPT 模型，以提高其在 NLP 任务上的性能。
• 生成模型：了解生成模型的基本概念和方法对于了解如何应用它们来构建自己的 GPT 模型至关重要。
• 语言建模：GPT 模型基于大量文本数据工作。因此，需要对语言建模有清晰的了解才能将其应用于 GPT 模型训练。
• Optimization：需要了解优化算法，例如随机梯度下降，以便在训练期间优化 GPT 模型。

除此之外，您需要熟练掌握以下任何一种编程语言，并对编程概念（例如面向对象编程、数据结构和算法）有扎实的理解，才能构建 GPT 模型。

• Python：深度学习和人工智能中最常用的编程语言。它有几个库，例如 TensorFlow、PyTorch 和 Numpy，用于构建和训练 GPT 模型。
• R：一种用于数据分析和统计建模的流行编程语言，具有多个用于深度学习和 AI 的软件包。
• Julia：一种高级、高性能的编程语言，非常适合数值和科学计算，包括深度学习。

你的 AI 了吗？让我们合作吧。

如何创建GPT模型？分步指南

在本节中，我们将通过代码片段展示使用 PyTorch 库和 transformer 架构从头开始构建 GPT（生成式预训练转换器）模型的步骤。该代码分为几个部分，按顺序执行以下任务：

• 数据预处理：代码的第一部分通过将输入文本数据标记化为单词列表，将每个单词编码为唯一的整数，并使用滑动窗口方法生成固定长度的序列来预处理输入文本数据。
• 型号配置：代码的这一部分定义了 GPT 模型的配置参数，包括 transformer 层数、注意力头数、隐藏层大小和词汇表大小。
• 模型架构：这部分代码使用 PyTorch 模块定义 GPT 模型的架构。该模型由一个嵌入层组成，后跟一堆转换器层，以及一个线性层，该线性层输出序列中下一个单词的词汇表上的概率分布。
• 训练循环：代码的这一部分定义了 GPT 模型的训练循环。它使用 Adam 优化器来最小化序列的预测和实际下一个单词之间的交叉熵损失。该模型在从预处理的文本数据生成的批次数据上进行训练。
• 文本生成：代码的最后一部分演示了如何使用经过训练的 GPT 模型生成新文本。它使用给定的种子序列初始化上下文，并通过从序列中下一个单词的模型输出的概率分布中采样来迭代生成新单词。生成的文本被解码回文字并打印到控制台。

我们将使用这个数据集 – https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt 来训练基于 Transformer 架构的模型。完整的代码可以从这里下载。

构建 GPT 模型涉及以下步骤：

导入库

第一步是导入使用 PyTorch 构建神经网络所需的库，其中包括导入必要的模块和函数。

import torch
import torch.nn as nn
from torch.nn import functional as F

在此代码片段中，开发人员正在导入 PyTorch 库，这是一个用于构建神经网络的流行深度学习框架。然后，开发人员从火炬库导入 nn 模块，该库包含用于定义和训练神经网络的类和函数。

定义超参数

下一步是定义用于构建 GPT 模型的各种超参数。这些超参数对于训练和微调 GPT 模型至关重要。这些超参数将决定模型的性能、速度和容量，开发人员可以试验不同的值来优化模型的行为。

# hyperparameters
batch_size = 16 # how many independent sequences will we process in parallel?
block_size = 32 # what is the maximum context length for predictions?
max_iters = 5000
eval_interval = 100
learning_rate = 1e-3
device = 'cuda' if torch.cuda.is_available() else 'cpu'
eval_iters = 200
n_embd = 64
n_head = 4
n_layer = 4
dropout = 0.0

此代码片段中定义的超参数包括：

• batch_size：此参数确定在训练期间将并行处理的独立序列的数量。较大的批处理大小可以加快训练速度，但需要更多的内存。
• block_size：此参数设置预测的最大上下文长度。GPT 模型根据它作为输入接收的上下文生成预测，此参数设置该上下文的最大长度。
• max_iters：此参数设置 GPT 模型的最大训练迭代次数。
• eval_interval：此参数设置训练迭代次数，之后将评估模型的性能。
• learning_rate：此参数决定了优化器在训练期间的学习率。
• device：此参数设置将在其上训练 GPT 模型的设备（CPU 或 GPU）。
• eval_iters：此参数设置训练迭代次数，之后将评估并保存模型的性能。
• n_embd：此参数设置 GPT 模型的嵌入维度数。嵌入层将输入序列映射到高维空间中，此参数决定了该空间的大小。
• n_head：此参数设置 GPT 模型多头注意力层中的注意力头数。注意力机制允许模型专注于输入序列的特定部分。
• n_layer：此参数设置 GPT 模型中的层数。
• dropout：此参数设置 GPT 模型的辍学概率。Dropout 是一种正则化技术，它在训练过程中随机丢弃神经网络的一些节点以防止过拟合。

读取输入文件

torch.manual_seed(1337)# wget https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt
with open('input.txt', 'r', encoding='utf-8') as f:
text = f.read()

在此代码片段中，开发人员使用 torch.manual_seed（） 为 PyTorch 的随机数生成器设置手动种子。这样做是为了确保 GPT 模型的结果具有可重复性。传递给 torch.manual_seed（） 的参数是一个任意数（在本例中为 1337），用作随机数生成器的种子。通过设置固定种子，开发人员可以确保每次运行代码时都生成相同的随机数序列，从而确保 GPT 模型在相同的数据上进行训练和测试。

接下来，开发人员使用 Python 的内置 open（） 函数读取文本文件，并使用 read（） 方法读取其内容。文本文件包含将用于训练 GPT 模型的输入文本。文本数据可以进一步预处理，例如，根据 GPT 模型的要求，通过清理文本、标记化文本和创建词汇表。一旦文本数据经过预处理，就可以通过 GPT 模型来生成预测。

识别文本中出现的唯一字符

chars = sorted(list(set(text)))
vocab_size = len(chars)

首先，我们使用 set（） 函数和 list（） 构造函数创建文本数据中存在的唯一字符的排序列表。set（） 函数从文本中返回唯一元素的集合，list（） 构造函数将该集合转换为列表。sorted（） 函数按字母顺序对列表进行排序，创建文本中存在的唯一字符的排序列表。

接下来，我们使用 len（） 函数获取字符列表的长度。这给出了文本中唯一字符的数量，并用作 GPT 模型的词汇量。

词汇量是一个重要的超参数，它决定了 GPT 模型的容量。词汇量越大，模型的表现力就越强，但它也增加了模型的复杂性和训练时间。词汇量通常是根据输入文本的大小和要解决的问题的性质来选择的。

创建词汇表后，文本数据中的字符可以映射到整数值，并通过 GPT 模型生成预测。

创建映射

第一步是在字符和整数之间创建映射，这对于构建 GPT 等语言模型是必要的。要使模型使用文本数据，它需要能够将每个字符表示为数值，这就是以下代码所完成的。

create a mapping from characters to integers
stoi = { ch:i for i,ch in enumerate(chars) }
itos = { i:ch for i,ch in enumerate(chars) }
encode = lambda s: [stoi[c] for c in s] # encoder: take a string, output a list of integers
decode = lambda l: ''.join([itos[i] for i in l]) # decoder: take a list of integers, output a stringprint(encode("hii there"))
print(decode(encode("hii there")))

此代码块为一组字符创建字符到整数的映射及其逆向（整数到字符的映射）。stoi 字典将每个字符映射到一个唯一的整数，而 itos 将每个整数映射回其相应的字符。encode 函数将字符串作为输入并返回整数列表，其中每个整数对应于字符集中字符的索引。decode 函数获取整数列表，并通过在 itos 字典中查找相应的字符来返回原始字符串。然后，该代码通过对字符串“hii there”进行编码，然后将生成的整数列表解码回字符串来测试编码和解码函数。

对输入数据进行编码

在构建 GPT 模型时，必须对整个文本数据集进行编码，以便将其输入到模型中。下面的代码正是这样做的。

let's now encode the entire text dataset and store it into a torch.Tensor
import torch # we use PyTorch: https://pytorch.org
data = torch.tensor(encode(text), dtype=torch.long)
print(data.shape, data.dtype)
print(data[:1000]) # the 1000 characters we looked at earier will to the GPT look like this

此代码导入 PyTorch 库并创建一个名为 data 的张量。张量填充编码后的文本数据，该数据是通过对文本变量调用编码函数获得的。dtype 参数设置为 torch.long，以确保张量元素为整数。该代码打印数据张量的形状和数据类型。shape 属性告诉我们每个维度上的张量大小，而 dtype 属性告诉我们张量元素的数据类型。此信息可用于验证张量是否已正确创建以及与 GPT 模型兼容。然后，它打印数据张量的前 1000 个元素，这些元素表示编码的文本数据。这对于验证编码过程是否正常工作以及数据是否已按预期加载到张量中非常有用。

将数据拆分为训练集和验证集

以下代码有助于了解 GPT 模型将如何处理输入数据。它显示了模型将如何处理长度为 block_size 的输入序列，以及输入和输出序列如何相互关联。这种理解有助于设计和训练 GPT 模型。

# Let's now split up the data into train and validation sets
n = int(0.9*len(data)) # first 90% will be train, rest val
train_data = data[:n]
val_data = data[n:]
block_size = 8
train_data[:block_size+1]
x = train_data[:block_size]
y = train_data[1:block_size+1]
for t in range(block_size):
context = x[:t+1]
target = y[t]
print(f"when input is {context} the target: {target}")

此代码将编码的文本数据拆分为训练集和验证集。前 90% 的数据分配给train_data变量，而其余 10% 的数据分配给val_data变量。它将block_size变量定义为 8，这决定了 GPT 模型一次将处理的输入序列大小。然后，它选择长度为 block_size+1 个元素的训练数据的一部分，并将其分配给train_data。x 变量被分配 train_data 的前 block_size 个元素，而 y 变量被分配 train_data 的下一个 block_size 元素，从第二个元素开始。换句话说，y 相对于 x 移动了一个位置。接下来，代码遍历 x 和 y 的block_size元素，并打印出输入序列中每个位置的输入上下文和目标。对于循环的每次迭代，上下文变量设置为 x 的前 t+1 元素，其中 t 的范围为 0 到 block_size-1。目标变量设置为 y 的第 t 个元素。然后，循环打印出一条消息，指示当前输入上下文和目标。

生成用于训练 GPT 的批量输入和目标数据

torch.manual_seed(1337)
batch_size = 4 # how many independent sequences will we process in parallel?
block_size = 8 # what is the maximum context length for predictions?def get_batch(split):
# generate a small batch of data of inputs x and targets y
data = train_data if split == 'train' else val_data
ix = torch.randint(len(data) - block_size, (batch_size,))
x = torch.stack([data[i:i+block_size] for i in ix])
y = torch.stack([data[i+1:i+block_size+1] for i in ix])
return x, yxb, yb = get_batch('train')
print('inputs:')
print(xb.shape)
print(xb)
print('targets:')
print(yb.shape)
print(yb)print('----')for b in range(batch_size): # batch dimension
for t in range(block_size): # time dimension
context = xb[b, :t+1]
target = yb[b,t]
print(f"when input is {context.tolist()} the target: {target}")

此代码将 PyTorch 的随机种子设置为 1337，这确保了随机数生成的确定性和可重现性。这对于训练 GPT 模型并获得一致的结果非常重要。它定义了batch_size和block_size变量。batch_size 指定每个批处理中将并行处理的独立序列数，而 block_size 指定预测的最大上下文长度。然后，它定义了一个名为 get_batch 的函数，该函数生成一小批输入 x 的数据，并为给定的拆分（train 或 val）以 y 为目标。该函数首先根据输入拆分选择适当的数据集（train_data 或 val_data）。然后，它使用 torch.randint（） 随机选择 x 的batch_size起始位置，确保每个起始位置距离数据集末尾至少 block_size 个位置，以避免越界。然后，它通过选择从每个起始位置开始的block_size元素来构造 x 和 y 张量，其中 y 相对于 x 向右移动一个位置。该函数以元组形式返回 x 和 y 张量。它使用参数“train”调用 get_batch（） 函数以生成一批训练数据。然后，它打印 x 和 y 张量的形状和内容。最后，它遍历批处理中的每个元素（维度 batch_size）和输入序列中的每个位置（维度 block_size），并打印出序列的输入上下文和每个位置的目标。上下文变量设置为 xb[b，：] 的前 t+1 元素，其中 t 的范围为 0 到 block_size-1。目标变量设置为 yb[b，：] 的第 t 个元素。然后，循环打印出一条消息，指示当前输入上下文和目标。

使用预训练模型计算训练和验证数据集的平均损失

@torch.no_grad()
def estimate_loss():
out = {}
model.eval()
for split in ['train', 'val']:
losses = torch.zeros(eval_iters)
for k in range(eval_iters):
X, Y = get_batch(split)
logits, loss = model(X, Y)
losses[k] = loss.item()
out[split] = losses.mean()
model.train()
return out

此代码定义了一个函数 estimate_loss（），该函数使用预训练模型计算训练和验证数据集的平均损失。它使用 @torch.no_grad（） 装饰器在评估期间禁用梯度计算，并使用 model.eval（） 将模型设置为评估模式。然后，它eval_iters次循环访问训练和验证数据集，使用预训练模型计算每个批次的日志和损失，并记录损失。最后，它返回两个数据集的平均损失，并使用 model.train（） 将模型设置回训练模式。此函数可用于在训练期间监视模型的性能并确定何时停止训练。

在Transformers模型中定义自注意力机制的一个头

class Head(nn.Module):
""" one head of self-attention """def __init__(self, head_size):
super().__init__()
self.key = nn.Linear(n_embd, head_size, bias=False)
self.query = nn.Linear(n_embd, head_size, bias=False)
self.value = nn.Linear(n_embd, head_size, bias=False)
self.register_buffer('tril', torch.tril(torch.ones(block_size, block_size)))self.dropout = nn.Dropout(dropout)def forward(self, x):
B,T,C = x.shape
k = self.key(x) # (B,T,C)
q = self.query(x) # (B,T,C)
# compute attention scores ("affinities")
wei = q @ k.transpose(-2,-1) * C**-0.5 # (B, T, C) @ (B, C, T) -> (B, T, T)
wei = wei.masked_fill(self.tril[:T, :T] == 0, float('-inf')) # (B, T, T)
wei = F.softmax(wei, dim=-1) # (B, T, T)
wei = self.dropout(wei)
# perform the weighted aggregation of the values
v = self.value(x) # (B,T,C)
out = wei @ v # (B, T, T) @ (B, T, C) -> (B, T, C)
return out

此代码定义了一个名为 Head 的模块，该模块表示 GPT 模型中使用的自注意力机制的一个头部。__init__ 方法初始化三个线性层（键、查询和值），这些层将用于将输入张量 x 投影到低维空间中，这有助于有效地计算注意力分数。正向方法将形状为 （batch_size、sequence_length、embedding_size） 的张量 x 作为输入，并使用点积注意力机制计算自注意力分数。注意力分数的计算方法是取查询和关键投影的点积，然后按嵌入大小的平方根对结果进行归一化。然后用三角形矩阵掩盖由此产生的注意力分数，以防止关注未来的代币。然后使用softmax函数对注意力分数进行归一化，乘以值投影，最后聚合以生成形状（batch_size，sequence_length，embedding_size）的输出张量。在最终聚合之前，将辍学层应用于注意力分数。

实现多头注意力机制

class MultiHeadAttention(nn.Module):
""" multiple heads of self-attention in parallel """def __init__(self, num_heads, head_size):
super().__init__()
self.heads = nn.ModuleList([Head(head_size) for _ in range(num_heads)])
self.proj = nn.Linear(n_embd, n_embd)
self.dropout = nn.Dropout(dropout)def forward(self, x):
out = torch.cat([h(x) for h in self.heads], dim=-1)
out = self.dropout(self.proj(out))
return out

此 PyTorch 模块实现了用于构建 GPT 模型的多头注意力机制。它包含许多磁头，每个磁头计算输入序列的自注意力矩阵。每个磁头的输出使用线性层连接并投影到原始嵌入尺寸，然后通过压差层。结果是一个相同长度的新序列，但具有更大的嵌入维度，对来自多个自注意力头的信息进行编码。该模块用作 GPT 模型中的构建块。

接下来我们需要添加 FeedFoward 模块

class FeedFoward(nn.Module):
""" a simple linear layer followed by a non-linearity """def __init__(self, n_embd):
super().__init__()
self.net = nn.Sequential(
nn.Linear(n_embd, 4 * n_embd),
nn.ReLU(),
nn.Linear(4 * n_embd, n_embd),
nn.Dropout(dropout),
)def forward(self, x):
return self.net(x)class Block(nn.Module):
""" Transformer block: communication followed by computation """def __init__(self, n_embd, n_head):
# n_embd: embedding dimension, n_head: the number of heads we'd like
super().__init__()
head_size = n_embd // n_head
self.sa = MultiHeadAttention(n_head, head_size)
self.ffwd = FeedFoward(n_embd)
self.ln1 = nn.LayerNorm(n_embd)
self.ln2 = nn.LayerNorm(n_embd)def forward(self, x):
x = x + self.sa(self.ln1(x))
x = x + self.ffwd(self.ln2(x))
return x

模型训练和文本生成

class BigramLanguageModel(nn.Module):def __init__(self):
super().__init__()
# each token directly reads off the logits for the next token from a lookup table
self.token_embedding_table = nn.Embedding(vocab_size, n_embd)
self.position_embedding_table = nn.Embedding(block_size, n_embd)
self.blocks = nn.Sequential(*[Block(n_embd, n_head=n_head) for _ in range(n_layer)])
self.ln_f = nn.LayerNorm(n_embd) # final layer norm
self.lm_head = nn.Linear(n_embd, vocab_size)def forward(self, idx, targets=None):
B, T = idx.shape# idx and targets are both (B,T) tensor of integers
tok_emb = self.token_embedding_table(idx) # (B,T,C)
pos_emb = self.position_embedding_table(torch.arange(T, device=device)) # (T,C)
x = tok_emb + pos_emb # (B,T,C)
x = self.blocks(x) # (B,T,C)
x = self.ln_f(x) # (B,T,C)
logits = self.lm_head(x) # (B,T,vocab_size)if targets is None:
loss = None
else:
B, T, C = logits.shape
logits = logits.view(B*T, C)
targets = targets.view(B*T)
loss = F.cross_entropy(logits, targets)return logits, lossdef generate(self, idx, max_new_tokens):
# idx is (B, T) array of indices in the current context
for _ in range(max_new_tokens):
# crop idx to the last block_size tokens
idx_cond = idx[:, -block_size:]
# get the predictions
logits, loss = self(idx_cond)
# focus only on the last time step
logits = logits[:, -1, :] # becomes (B, C)
# apply softmax to get probabilities
probs = F.softmax(logits, dim=-1) # (B, C)
# sample from the distribution
idx_next = torch.multinomial(probs, num_samples=1) # (B, 1)
# append sampled index to the running sequence
idx = torch.cat((idx, idx_next), dim=1) # (B, T+1)
return idxmodel = BigramLanguageModel()
m = model.to(device)
# print the number of parameters in the model
print(sum(p.numel() for p in m.parameters())/1e6, 'M parameters')# create a PyTorch optimizer
optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)for iter in range(max_iters):# every once in a while evaluate the loss on train and val sets
if iter % eval_interval == 0 or iter == max_iters - 1:
losses = estimate_loss()
print(f"step {iter}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}")# sample a batch of data
xb, yb = get_batch('train')# evaluate the loss
logits, loss = model(xb, yb)
optimizer.zero_grad(set_to_none=True)
loss.backward()
optimizer.step()# generate from the model
context = torch.zeros((1, 1), dtype=torch.long, device=device)
print(decode(m.generate(context, max_new_tokens=2000)[0].tolist()))

BigramLanguageModel 类定义为 nn 的子类。模块，并包含用于构建模型的多个层。__init__ 方法使用标记的嵌入层和标记位置的单独嵌入层初始化模型。此外，该模型还具有一系列转换器模块（由 Block 函数定义）以及最终层范数和线性层，用于输出下一个标记的日志。forward 方法接收输入序列和目标，计算嵌入，应用转换器模块，并输出下一个令牌的日志以及提供目标时的损失。

generate 方法用于从模型生成新的文本序列。它需要一个起始序列和最大数量的新代币来生成。该方法从模型的预测概率分布中迭代采样下一个标记，并将其追加到运行序列中，直到达到所需的长度。

在代码的主要部分，将创建 BigramLanguageModel 类的实例并将其移动到指定的设备。然后创建 PyTorch AdamW 优化器，并开始训练循环。在每次迭代中，使用 get_batch 函数从训练集中采样一批数据。然后对这批数据评估模型，计算损失，并使用loss.backward（）反向传播梯度。最后，调用优化器的 step（） 方法来更新模型的参数。

训练后，generate 方法用于从训练的模型生成文本序列。创建一个零的上下文张量，并使用此上下文和要生成的最大数量的新标记调用 generate 方法。使用 decode 函数对生成的标记序列进行解码，以生成生成的文本字符串。

如何使用您的数据训练现有的 GPT 模型？

上一部分介绍了如何从头开始构建 GPT 模型。现在，让我们深入研究使用您的唯一数据增强预先存在的模型的过程。这被称为“微调”，这是一个为特定任务或数据集优化基本或“基础”模型的过程。OpenAI 提供了一系列可以利用的基础模型，GPT-NeoX 就是一个值得注意的例子。如果您有兴趣使用您的数据微调 GPT-NeoX，以下步骤将指导您完成整个过程。

GPT-NeoX 的完整代码可以从这里下载——https://github.com/EleutherAI/gpt-neox

先决条件

GPT-NeoX 需要一些环境设置，以及在使用模型之前设置的依赖关系。以下是详细信息——

设置主机

首先，请确保您的环境配备了 Python 3.8 和合适的 PyTorch 1.8 或更高版本。请注意，GPT-NeoX 依赖于某些可能与 Python 3.10 及更高版本不兼容的库。Python 3.9 似乎可以运行，但我们的代码库主要是使用 Python 3.8 设计和测试的。

要设置其他必需的依赖项，请从存储库根目录执行以下命令：

pip install -r requirements/requirements.txt
python ./megatron/fused_kernels/setup.py install # optional if not using fused kernels

此处使用的代码库基于 DeeperSpeed，它是 DeepSpeed 库的自定义版本。DeeperSpeed 是 Microsoft DeepSpeed 库的一个专门分支，它是根据 GPT-NeoX 项目的需求定制的。它带有 EleutherAI 专门为 GPT-NeoX 量身定制的额外更改。我们强烈建议在继续操作之前使用环境隔离工具（如 Anaconda）或虚拟机。这一点至关重要，因为不这样做可能会中断其他依赖于 DeepSpeed 的存储库。

闪光关注

要使用 Flash-Attention，请首先安装 ./requirements/requirements-flashattention.txt 中指定的额外依赖项。然后，根据需要调整配置中的注意类型（请参阅配置）。这种修改可以大大提高性能，尤其是在某些 GPU 架构上，如 Ampere GPU（如 A100）。有关详细信息，请参阅存储库。

容器化设置

如果您更喜欢容器化执行，则可以使用 Dockerfile 来运行 NeoX。要利用此功能，请首先使用以下命令从存储库的根目录创建一个名为 gpt-neox 的映像

docker build -t gpt-neox -f Dockerfile ..

在此之后，您可以根据创建的映像执行容器。例如，下面的命令将克隆的存储库目录 （gpt-neox） 附加到容器中的 /gpt-neox，并使用 nvidia-docker 授予容器对四个 GPU（编号为 0-3）的访问权限。

用法

您应该利用 deepy.py（deepspeed 启动器周围的包装器）来触发所有功能，包括推理。

有三个主要功能可供您使用：

1. train.py：这用于训练和微调模型。
2. evaluate.py：使用此功能使用语言模型评估工具评估经过训练的模型。
3. generate.py：此函数用于从经过训练的模型中对文本进行采样。

您可以使用以下命令启动它们：

./deepy.py [script.py] [./path/to/config_1.yml] [./path/to/config_2.yml] ... [./path/to/config_n.yml]

例如，要使用 GPT-NeoX-20B 模型无条件生成文本，请使用：

./deepy.py generate.py ./configs/20B.yml

您还可以选择输入文本文件（例如，prompt.txt）作为提示。这应该是一个普通的.txt文件，每个提示都用换行符分隔。请记住将路径传递到输出文件。

./deepy.py generate.py ./configs/20B.yml -i prompt.txt -o sample_outputs.txt

要在 TriviaQA 和 PIQA 等任务上复制我们的评估数字，请使用：

./deepy.py evaluate.py ./configs/20B.yml --eval_tasks triviaqa piqa

配置

GPT-NeoX 操作由 YAML 配置文件中的参数控制，该文件提供给 deepy.py 启动器。我们在 configs 文件夹中包含了一些示例 .yaml 文件，包括一个用于 GPT-NeoX-20B 的文件，以及用于其他模型大小的示例配置。

这些文件通常是包罗万象的，但不一定是优化的。根据您的特定 GPU 设置，您可能需要调整设置，例如 pipe-parallel-size、model-parallel-size 以实现并行性、train_micro_batch_size_per_gpu 或 gradient-accumulation-steps 用于批量大小调整，或者 zero_optimization dict 用于优化器状态并行化。

有关可用功能及其配置的深入指南，请参阅配置自述文件。有关所有可能参数的详细信息，请查看 configs/neox_arguments.md。

数据准备

以 GPT NeoX 模型接受的格式准备文本数据。这通常涉及使用适用于 GPT NeoX 模型的分词器进行分词化。

对于使用个性化数据进行训练，您需要将数据集格式化为大型 jsonl 文件，其中每个字典项表示一个单独的文档。文档文本应位于单个 JSON 键下，特别是“text”。其他字段中的任何其他数据都将被忽略。

然后，确保您已下载 GPT2 分词器词汇表和合并文件。以下链接将引导您访问它们：

词汇： https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-vocab.json

合并文件： https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-merges.txt

现在，您可以使用 tools/preprocess_data.py 中的脚本对数据进行预标记。下面介绍了此脚本的必要参数：

python tools/preprocess_data.py \
--input ./data/mydataset.jsonl.zst \
--output-prefix ./data/mydataset \
--vocab ./data/gpt2-vocab.json \
--merge-file gpt2-merges.txt \
--dataset-impl mmap \
--tokenizer-type GPT2BPETokenizer \
--append-eod

要继续训练，应将以下设置合并到配置文件中：

"data-path": "data/mydataset/mydataset",

训练和微调

使用“deepy.py”开始您的训练，这是 DeepSpeed 启动器的包装器。它跨多个 GPU 或节点并行执行脚本。

python ./deepy.py train.py [path/to/config1.yml] [path/to/config2.yml] ...

您可以提供任意数量的配置文件，这些文件将在脚本运行时合并。

（可选）您可以包含配置前缀，这是所有配置文件的通用路径。

例如。执行以下代码 –

python ./deepy.py train.py -d configs 125M.yml local_setup.yml

此指令在网络的每个节点上执行“train.py”脚本，每个 GPU 运行脚本的一个实例。这意味着所有节点上的每个 GPU 都将单独运行“train.py”脚本。工作节点和 GPU 数量在“/job/hostfile”文件中定义（请参阅参数文档），或者如果您运行的是单节点设置，则可以简单地作为“num_gpus”参数包含在内。

我们建议在一个配置文件（如 'configs/125M.yml'）中定义模型参数，在另一个配置文件（如 'configs/local_setup.yml'）中定义数据路径参数，以便更好地组织，尽管这不是强制性的。

构建 GPT 模型时要考虑的事项

消除偏见和毒性

当我们努力构建强大的生成式人工智能模型时，我们必须意识到随之而来的巨大责任。重要的是要承认，像 GPT 这样的模型是在来自互联网的大量不可预测的数据上训练的，这可能会导致最终产品中的偏见和有毒语言。随着人工智能技术的发展，负责任的做法变得越来越重要。我们必须确保我们的人工智能模型的开发和部署符合道德规范，并牢记社会责任。优先考虑负责任的人工智能实践对于降低偏见和有毒内容的风险至关重要，同时充分释放生成式人工智能创造更美好世界的潜力。

有必要采取积极主动的方法，确保人工智能模型生成的输出没有偏见和毒性。这包括过滤训练数据集以消除潜在的有害内容，并实施看门狗模型以实时监控输出。此外，利用第一方数据来训练和微调 AI 模型可以显着提高其质量。这允许自定义以满足特定用例，从而提高整体性能。

改善幻觉

必须承认，虽然 GPT 模型可以产生令人信服的论点，但它们可能并不总是基于事实的准确性。在开发者社区中，这个问题被称为“幻觉”，它会降低这些 AI 模型生成的输出的可靠性。为了克服这一挑战，您需要考虑 OpenAI 和其他供应商采取的措施，包括数据增强、对抗训练、改进模型架构和人工评估，以提高输出的准确性并降低幻觉的风险，并确保模型生成的输出尽可能精确和可靠。

防止数据泄露

建立透明的政策对于防止开发人员将敏感信息传递到 GPT 模型中至关重要，这些模型可以合并到模型中并在公共环境中重新出现。通过实施此类政策，我们可以防止敏感信息的无意泄露，保护个人和组织的隐私和安全，并避免任何负面后果。这对于保持警惕，防范与使用GPT模型相关的潜在风险并采取积极措施来减轻这些风险至关重要。

合并查询和操作

当前的生成模型可以根据其初始的大型训练数据集或较小的“微调”数据集提供答案，这些数据集不是实时和历史的。然而，下一代车型将取得重大飞跃。这些模型将具备识别何时从外部来源（如数据库或谷歌）寻求信息或触发外部系统中操作的能力，从而将生成模型从孤立的预言机转变为与世界完全连接的对话界面。通过启用这种新的连接水平，我们可以为这些模型解锁一组新的用例和可能性，从而创建更加动态和无缝的用户体验，提供实时、相关的信息和见解。

结尾

GPT 模型是 AI 发展史上的一个重要里程碑，它是未来将增长的更大 LLM 趋势的一部分。此外，OpenAI 提供 API 访问的开创性举措是其模型即服务业务计划的一部分。此外，GPT 基于语言的功能允许创建创新产品，因为它擅长文本摘要、分类和交互等任务。GPT模型有望塑造未来的互联网以及我们使用技术和软件的方式。构建 GPT 模型可能具有挑战性，但通过正确的方法和工具，它成为一种有益的体验，为 NLP 应用程序开辟了新的机会。