简单的公司网站系统,网站建设费用上海,wordpress文章图片加水印,外贸营销推广OpenAI 推出强大的生成式预训练转换器 #xff08;GPT#xff09; 语言模型#xff0c;为自然语言处理 #xff08;NLP#xff09; 开辟了新的领域。将 GPT 模型集成到虚拟助手和聊天机器人中可以增强它们的能力#xff0c;这导致对 GPT 模型的需求激增。根据 Allied Mar… 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 的三个组成部分即生成、预训练和转换器并了解它们的含义。 生成生成模型是用于生成新数据的统计模型。这些模型可以学习数据集中变量之间的关系以生成与原始数据集中的数据点类似的新数据点。 预训练这些模型已经使用大型数据集进行了预训练当难以训练新模型时可以使用该数据集。尽管预训练模型可能并不完美但它可以节省时间并提高性能。 TransformerTransformer 模型是 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 模型有助于增强计算机理解和处理人类语言的能力。这包括两个主要方面 人类语言理解 HLUHLU是指机器理解句子和短语含义的能力有效地将人类知识翻译成机器可读的格式。这是使用深度神经网络或前馈神经网络实现的涉及统计、概率、决策树、模糊集和强化学习技术的复杂组合。在这一领域开发模型具有挑战性需要大量的专业知识、时间和资源。自然语言处理 NLPNLP专注于解释和分析书面或口头的人类语言。它涉及训练计算机理解语言而不是使用预先设定的规则或指令对它们进行编程。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 BERT来自Transformer 的双向编码器表示 ELMo 来自语言模型的嵌入 预训练方法单向语言建模双向语言建模掩码语言建模和下一句预测单向语言建模预训练数据来自互联网的大量文本来自互联网的大量文本内部和外部语料库的组合架构Transformer网络Transformer网络深度双向LSTM网络输出上下文感知令牌级嵌入上下文感知标记级和句子级嵌入上下文感知词级嵌入微调方法多任务微调例如文本分类、序列标记多任务微调例如文本分类、问答对单个任务进行微调优势可生成文本微调灵活性高模型尺寸大在各种 NLP 任务中表现出色同时考虑两个方向的上下文生成特定于任务的特征考虑整个输入序列的上下文局限性可能会生成有偏见或不准确的文本需要大量数据仅限于微调需要特定于任务的架构修改;需要大量数据有限的上下文和特定于任务的上下文;需要特定于任务的体系结构修改 如何选择适合您需求的 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技术及其应用有一个基本的了解。TransformersGPT 模型基于 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, encodingutf-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) 在此代码片段中我们将为 GPT 模型创建一个词汇表。 首先我们使用 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 模型时必须对整个文本数据集进行编码以便将其输入到模型中。下面的代码正是这样做的。 lets 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), dtypetorch.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 模型。 # Lets 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_size1]
x train_data[:block_size]
y train_data[1:block_size1]
for t in range(block_size):
context x[:t1]
target y[t]
print(fwhen input is {context} the target: {target}) # 此代码将编码的文本数据拆分为训练集和验证集。前 90% 的数据分配给train_data变量而其余 10% 的数据分配给val_data变量。它将block_size变量定义为 8这决定了 GPT 模型一次将处理的输入序列大小。然后它选择长度为 block_size1 个元素的训练数据的一部分并将其分配给train_data。x 变量被分配 train_data 的前 block_size 个元素而 y 变量被分配 train_data 的下一个 block_size 元素从第二个元素开始。换句话说y 相对于 x 移动了一个位置。接下来代码遍历 x 和 y 的block_size元素并打印出输入序列中每个位置的输入上下文和目标。对于循环的每次迭代上下文变量设置为 x 的前 t1 元素其中 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:iblock_size] for i in ix])
y torch.stack([data[i1:iblock_size1] 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, :t1]
target yb[b,t]
print(fwhen 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] 的前 t1 元素其中 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, biasFalse)
self.query nn.Linear(n_embd, head_size, biasFalse)
self.value nn.Linear(n_embd, head_size, biasFalse)
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_sizesequence_lengthembedding_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 wed 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_headn_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, targetsNone):
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, devicedevice)) # (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_samples1) # (B, 1)
# append sampled index to the running sequence
idx torch.cat((idx, idx_next), dim1) # (B, T1)
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(), lrlearning_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(fstep {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_noneTrue)
loss.backward()
optimizer.step()# generate from the model
context torch.zeros((1, 1), dtypetorch.long, devicedevice)
print(decode(m.generate(context, max_new_tokens2000)[0].tolist())) 此代码使用 PyTorch 定义一个 bigram 语言模型来训练 GPT 模型。 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 .. 此外您可以在 Docker Hub 上的 leogao2/gpt-neox 上获取预构造的映像。 在此之后您可以根据创建的映像执行容器。例如下面的命令将克隆的存储库目录 gpt-neox 附加到容器中的 /gpt-neox并使用 nvidia-docker 授予容器对四个 GPU编号为 0-3的访问权限。 用法 您应该利用 deepy.pydeepspeed 启动器周围的包装器来触发所有功能包括推理。 有三个主要功能可供您使用 train.py这用于训练和微调模型。evaluate.py使用此功能使用语言模型评估工具评估经过训练的模型。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 中的脚本对数据进行预标记。下面介绍了此脚本的必要参数 nu 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 [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 应用程序开辟了新的机会。
