ToB企服应用市场:ToB评测及商务社交产业平台

标题: AIGC实战——GPT(Generative Pre-trained Transformer) [打印本页]
作者: 老婆出轨    时间: 2024-8-5 19:25
标题: AIGC实战——GPT(Generative Pre-trained Transformer)
0. 媒介

注意力机制能够用于构建先辈的文本天生模型，Transformer 是用于序列建模的强大神经网络，该神经网络不需要复杂的循环或卷积架构，而只依赖于注意力机制。这种方法克服了循环神经网络 (Recurrent Neural Network, RNN) 方法难以并行化的缺陷( RNN 必须逐符号处置惩罚序列)。Transformers 高度可并行化运算，能够在大规模数据集上举行训练。在本节中，我们将学习文本天生模型怎样利用 Transformer 架构进步文天性能，并先容自回归模型 GPT (Generative Pre-Trained transformer)。
1. GPT 简介

OpenAI 于 2018 年提出 GPT (Generative Pre-Trained transformer)，将 Transformer 架构用于训练大规模文本数据，以猜测序列数据中的下一个单词，然后再针对特定的下游任务举行微调。
GPT 的预训练过程利用大型文本语料库 BookCorpus (来自 7000 本差异范例册本的 4.5GB 文本)训练模型。在预训练过程中，模型会根据先前的单词猜测序列中的下一个单词，这一过程称为语言建模 (language modeling)，用于训练模型明白自然语言的结构和模式。
在预训练之后，通过利用一个特定任务的小规模数据集，可以对 GPT 模型举行微调。微调表现调解模型的参数以更好地顺应当前任务。例如，可以针对分类、问答等任务对模型举行微调。
OpenAI 对 GPT 架构举行了改进和扩展，后续提出了 GPT-2、GPT-3、GPT-3.5 和 GPT-4 等模型。这些模型在更大的数据集上举行训练，具有更大的容量，因此可以天生更复杂、更连贯的文本，GPT 模型已经被广泛应用于自然语言处置惩罚相干任务中。
在本节中，我们将利用雷同的组件和基本原理构建 GPT 模型，差异的是，我们利用较少的数据举行训练。
2. 葡萄酒评论数据集

在本节中，利用 Kaggle 中的葡萄酒评论数据集训练 GPT 模型，数据会合包罗超过 130,000 条葡萄酒评论，以及相干描述和代价等元数据。
可以在 Kaggle 中下载数据集，解压后，将葡萄酒评论和相干元数据保存到 ./data 文件夹中。数据准备流程与利用 LSTM 训练天生模型中所用的数据准备步骤雷同：


3. 注意力机制

明白 GPT 工作原理的第一步是明白注意力机制 (attention mechanism)，注意力机制使得 Transformer 架构在语言建模方面与循环神经网络有所差异。明白了注意力机制后，便能了解怎样在 Transformer 架构(如 GPT )中利用注意力机制。
当我们写作时，句子中的下一个单词受到已经写完的其他单词的影响。例如，假设以以下方式开始一个句子：
  1. "The write elephant tried to get into the boat but it was too"
复制代码
显然，下一个词应该是与 “big” 意思相近的单词。句子中的其他词对于下一单词的选择非常紧张。例如，它是 elephant 而不是 bird，这意味着我们更倾向于选取 “big” 而不是 “small”，假如句中利用 “pool” 而不是 “boat”，我们可能会选择 “scared” 替换 “big”。最后，把 “elephant” 放进小船里意味着尺寸是问题所在，假如大象试图摧毁小船，我们可能会选择 “flexible” 作为最后一个词，其中 “it” 指的是 “boat”。
除此之外，句子中的其他词则并不紧张。例如，大象是 “white” 或“black”对于选择最后一个词没有任何影响。同样，句子中的其他单词，如 the，but，it 等，为句子构成了正确的语法形式，但对于确定下一个所需单词并不紧张。换句话说，我们只关注句子中的某些单词，而对其他词只付出少量关注，我们希望深度学习模型同样能够做到这一点。
Transformer 中的注意力机制(也称为注意力头)就是为了实现这一目的。它能够决定在输入中从哪些部分中获取信息，以便高效地提取有用的信息而不被无关细节所干扰。这使得它能够顺应各种环境，由于它可以在推理时决定在哪些部分中探求信息。
相比之下，循环层试图构建一个通用的隐藏状态，用以在每个时间步捕捉输入的整体表现。这种方法的一个缺点是，合并到隐藏向量中的许多单词对于当前任务(如猜测下一个单词)可能并不直接相干。注意力头则可以制止此问题，由于它们可以选择怎样结合上下文的信息。
3.1 查询、键和值

接下来，我们先容注意力机制怎样决定在哪里探求信息，我们继续利用上一节中所用示例。
为了能够猜测单词 “too” 之后的内容，前面的其他单词都会有所贡献，但它们的贡献取决于它们对于猜测 “too” 后续单词的能力的自信水平。例如，单词 “elephant” 可能会自信地贡献出与尺寸相干的词，而单词 “was” 没有提供太多的信息来缩小可能性。
换句话说，我们可以将注意力头看作一种信息检索系统，其中查询(“接在 too 之后的词是什么？”)被转化为键/值存储(句子中的其他单词)，输出结果是值的总和，并根据查询与每个键之间的相干度举行加权。此过程详细步骤如下图所示，我们的仍然利用上一节所用示例。

查询 (query, Q) 可以表现当前任务(例如，“接在 too 之后的词是什么？”)。在本例中，通过将单词 “too” 的嵌入通报到权重矩阵                                              W                            Q                                       W_Q                  WQ​ 中，从维度                                              d                            e                                       d_e                  de​ 变换为维度                                              d                            k                                       d_k                  dk​，得到了查询。
键向量 (key, K) 是句子中每个单词的表现，可以将其视为每个单词可以资助完成的猜测任务的贡献。它们与查询的产生方式类似，通过将每个嵌入通报到权重矩阵                                              W                            K                                       W_K                  WK​ 中，将每个向量的维度从                                              d                            e                                       d_e                  de​ 变换为                                              d                            k                                       d_k                  dk​，键和查询的长度雷同。
在注意力头中，利用每对向量 (                                             Q                            K                                       Q_K                  QK​) 之间的点积将每个键与查询举行比较(这就是键和查询必须具有雷同的长度的原因)。键/查询对的点积结果数值越高，键与查询的相干度就越强，因此允许它对注意力头的输出做出更大的贡献。得到的向量乘以                                              d                            k                                       d_k                  dk​，以保持向量和的方差稳固(大约等于 1)，并应用 softmax 函数确保贡献总和为 1，这便是注意力权重向量。
值向量 (value, V) 也是句子中单词的表现，可以将其视为每个单词的未加权贡献。通过将每个嵌入通报到权重矩阵                                              W                            V                                       W_V                  WV​ 中，将每个向量的维度从                                              d                            e                                       d_e                  de​ 变换为                                              d                            v                                       d_v                  dv​，得到值向量。需要注意的是，值向量不一定与键和查询具有雷同的长度(但通常为简单起见，利用雷同长度)。
值向量乘以注意力权重，得到给定                                    Q                              Q                  Q、                                   K                              K                  K 和                                    V                              V                  V 的注意力：
                                         A                            t                            t                            e                            n                            t                            i                            o                            n                            (                            Q                            ,                            K                            ,                            V                            )                            =                            s                            o                            f                            t                            m                            a                            x                            (                                                   Q                                               K                                     T                                                                               d                                     k                                                             )                            V                                  Attention(Q,K,V)=softmax(\frac {QK^T} {\sqrt {d_k}})V                     Attention(Q,K,V)=softmax(dk​                    ​QKT​)V
为了从注意力头得到终极输出向量，将注意力举行求和，得到长度为                                              d                            v                                       d_v                  dv​ 的向量。这个上下文向量捕捉了句子中的单词对于猜测接在 too 之后的词的任务的共同意见。
3.2 多头注意力

在 Keras 中，可以构建 MultiHeadAttention 层，该层将多个注意力头的输出连接起来构成多头注意力 (Multihead Attention)，允许每个头学习差异的注意力机制，以便整个层可以学习更复杂的关系。
连接后的输出通过终极的权重矩阵                                              W                            O                                       W_O                  WO​ 举行投影，将向量投影到期望的输出维度上。在本节下，输出维度与查询的输入维度雷同 (                                             d                            e                                       d_e                  de​)，以便可以将层按序次堆叠在一起。下图表现了 MultiHeadAttention 层输出的构建方式。

在 Keras 中创建 MultiHeadAttention 层：
  1. layers.MultiHeadAttention(
  2.     # 此多头注意力层有四个注意力头
  3.     num_heads = 4,
  4.     # 键(和查询)是长度为 128 的向量
  5.     key_dim = 128,
  6.     # 值(也是每个头的输出)是长度为 64 的向量
  7.     value_dim = 64,
  8.     # 输出向量的长度为 256
  9.     output_shape = 256
  10. )
复制代码
3.3 因果掩码

在以上先容中，我们假设注意力头的查询输入是一个单一的向量。然而，为了在训练期间进步效率，理想环境下我们希望注意力层能够同时处置惩罚输入中的每个单词，为每个单词猜测后续的单词。换句话说，我们希望我们的 GPT 模型能够同时处置惩罚一组查询向量(即矩阵)。
为了将向量批处置惩罚成一个矩阵，并利用线性代数举行处置惩罚，我们需要一个额外的步骤，我们需要对查询/键的点积应用掩码，以制止未来单词的信息泄漏，这称为因果掩码 (Causal Masking)，如下图所示。

假如没有这个掩码，GPT 模型将能够完善地猜出句子中的下一个单词，由于它将利用来自单词本身的键作为一个特性。利用 Keras 创建因果掩码，下图表现了 Numpy 形式的结果数组(为了与图相匹配，将结果数组举行了转置)。
  1. def causal_attention_mask(batch_size, n_dest, n_src, dtype):
  2.     i = tf.range(n_dest)[:, None]
  3.     j = tf.range(n_src)
  4.     m = i >= j - n_src + n_dest
  5.     mask = tf.cast(m, dtype)
  6.     mask = tf.reshape(mask, [1, n_dest, n_src])
  7.     mult = tf.concat(
  8.         [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)], 0
  9.     )
  10.     return tf.tile(mask, mult)
  12. print(np.transpose(causal_attention_mask(1, 10, 10, dtype=tf.int32)[0]))
复制代码
因果掩码仅在解码器 Transformer(如 GPT )中需要，在这些模型中，任务是根据先前的符号序次天生符号，在训练期间掩码掉未来的符号是至关紧张的。
其他范例的 Transformer (例如编码器 Transformer )不需要因果掩码，由于它们不是通过猜测下一个符号来训练的。例如，Google 的 BERT 在给定句子中猜测待填空的单词，因此它可以利用该词前后的上下文。
Transformer 中的多头注意力机制中，层的可学习参数仅由每个注意力头的三个权重矩阵 (                                             W                            Q                                       W_Q                  WQ​、                                             W                            K                                       W_K                  WK​、                                             W                            V                                       W_V                  WV​) 和一个用于重塑输出的权重矩阵 (                                             W                            O                                       W_O                  WO​) 构成，在多头注意力层中完全没有卷积或循环机制。
下一节中，我们将先容怎样利用多头注意力层构建 Transformer 块。
4. Transformer

4.1 Transformer 块

Transformer 块是 Transformer 内的一个组件，它在多头注意力层间应用了跳跃连接、前馈(全连接)层 (Feed-forward layers) 和归一化，Transformer 块的结构如下图所示。

起首，将查询通报到多头注意力层并直接添加到输出中，这是一种跳跃连接，可以用其构建非常深的神经网络，而不会受到梯度消散问题的影响，由于跳跃连接提供了一个无梯度的数据通道，使网络能够直接通报信息。
其次，在 Transformer 块中的层归一化用于进步训练过程的稳固性。我们已经先容了怎样利用批归一化层，在批归一化中，每个通道的输出被归一化为均值为 0，尺度差为 1，归一化统计信息是根据批和空间维度计算的。
而在 Transformer 块中的层归一化通过在通道维度上计算归一化统计信息，对批数据中每个序列的每个位置举行归一化。就统计信息的计算方式而言，它与批归一化完全相反，下图展示了批归一化和层归一化之间的差异。
层归一化常用于基于文本的任务中，以制止在批处置惩罚中跨序列创建归一化依赖关系。然而，Shen 等人表明在 Transformer 内部可以利用一种形式的批归一化举行调解，从而优于传统的层归一化方法。

最后，在 Transformer 块中包罗了一组前馈(全连接)层( Feed-forward layers )，以使组件能够在网络中深入提取更高级别的特性。
利用 Keras 实现一个 Transformer 块。
  1. class TransformerBlock(layers.Layer):
  2.     # 在初始化函数中定义构成 TransformerBlock 层的子层
  3.     def __init__(self, num_heads, key_dim, embed_dim, ff_dim, dropout_rate=0.1):
  4.         super(TransformerBlock, self).__init__()
  5.         self.num_heads = num_heads
  6.         self.key_dim = key_dim
  7.         self.embed_dim = embed_dim
  8.         self.ff_dim = ff_dim
  9.         self.dropout_rate = dropout_rate
  10.         self.attn = layers.MultiHeadAttention(
  11.             num_heads, key_dim, output_shape=embed_dim
  12.         )
  13.         self.dropout_1 = layers.Dropout(self.dropout_rate)
  14.         self.ln_1 = layers.LayerNormalization(epsilon=1e-6)
  15.         self.ffn_1 = layers.Dense(self.ff_dim, activation="relu")
  16.         self.ffn_2 = layers.Dense(self.embed_dim)
  17.         self.dropout_2 = layers.Dropout(self.dropout_rate)
  18.         self.ln_2 = layers.LayerNormalization(epsilon=1e-6)
  20.     def call(self, inputs):
  21.         input_shape = tf.shape(inputs)
  22.         batch_size = input_shape[0]
  23.         seq_len = input_shape[1]
  24.         # 创建因果掩码，以隐藏查询中未来的键
  25.         causal_mask = causal_attention_mask(
  26.             batch_size, seq_len, seq_len, tf.bool
  27.         )
  28.         # 创建多头注意力层，并指定注意力掩码
  29.         attention_output, attention_scores = self.attn(
  30.             inputs,
  31.             inputs,
  32.             attention_mask=causal_mask,
  33.             return_attention_scores=True,
  34.         )
  35.         attention_output = self.dropout_1(attention_output)
  36.         # 第一个 add 和归一化层
  37.         out1 = self.ln_1(inputs + attention_output)
  38.         # 前馈层
  39.         ffn_1 = self.ffn_1(out1)
  40.         ffn_2 = self.ffn_2(ffn_1)
  41.         # 第二个 add 和归一化层
  42.         ffn_output = self.dropout_2(ffn_2)
  43.         return (self.ln_2(out1 + ffn_output), attention_scores)
复制代码
4.2 位置编码

在训练 GPT 模型之前，另有一个最后一步需要处置惩罚。在多头注意力层中，并没有关注键的序次。每个键与查询之间的点积是并行计算的，而非像循环神经网络那样序次计算。这样可以并行化处置惩罚以进步效率，但也带来了一个问题，由于我们需要注意力层能够思量文本的上下文信息，例如，针对以下两个句子猜测差异的输出：
  1. The dog looked at the boy and … (barked?)
  2. The boy looked at the dog and … (smiled?)
复制代码
为了解决这个问题，在创建初始的 Transformer 块的输入时，我们利用一种称为位置编码 (positional encoding) 的技术。我们不但利用符号嵌入 (token embedding) 来编码每个符号，还利用位置嵌入 (position embedding) 来编码符号的位置。
符号嵌入利用尺度的嵌入层将每个符号转换为一个可学习向量。我们可以利用雷同的方式创建位置编码，利用尺度的嵌入层将每个整数位置转换为一个可学习向量。虽然 GPT 利用嵌入层来嵌入位置信息，但原始 Transformer 论文利用三角函数。
为了构建联合的符号-位置编码，将符号嵌入添加到位置嵌入中，如下图所示。这样，就可以在一个向量中同时捕捉序列中每个词的含义和位置信息。

利用 Keras 界说 TokenAndPositionEmbedding 层：
  1. class TokenAndPositionEmbedding(layers.Layer):
  2.     def __init__(self, max_len, vocab_size, embed_dim):
  3.         super(TokenAndPositionEmbedding, self).__init__()
  4.         self.max_len = max_len
  5.         self.vocab_size = vocab_size
  6.         self.embed_dim = embed_dim
  7.         # 符号使用 Embedding 层获取嵌入
  8.         self.token_emb = layers.Embedding(
  9.             input_dim=vocab_size, output_dim=embed_dim
  10.         )
  11.         # 符号的位置同样使用 Embedding 层获取嵌入
  12.         self.pos_emb = layers.Embedding(input_dim=max_len, output_dim=embed_dim)
  14.     def call(self, x):
  15.         maxlen = tf.shape(x)[-1]
  16.         positions = tf.range(start=0, limit=maxlen, delta=1)
  17.         positions = self.pos_emb(positions)
  18.         x = self.token_emb(x)
  19.         # TokenAndPositionEmbedding 层的输出是符号嵌入和位置嵌入之和
  20.         return x + positions
复制代码
5. 训练GPT

接下来，构建并训练 GPT 模型。将输入文本通过符号和位置嵌入层，然后通过 Transformer 块，网络的终极输出是一个利用 softmax 激活函数的 Dense 层，输出的维度是词汇表中的单词数。为了简单起见，我们仅利用一个 Transformer块( GPT 论文中利用 12 个)，整体架构如下图所示。

利用 Keras 实现此架构：
  1. # 用 0 填充输入
  2. inputs = layers.Input(shape=(None,), dtype=tf.int32)
  3. # 文本使用 TokenAndPositionEmbedding 层获取嵌入
  4. x = TokenAndPositionEmbedding(MAX_LEN, VOCAB_SIZE, EMBEDDING_DIM)(inputs)
  5. # 嵌入通过 TransformerBlock 进行传递
  6. x, attention_scores = TransformerBlock(N_HEADS, KEY_DIM, EMBEDDING_DIM, FEED_FORWARD_DIM)(x)
  7. # 转换后的输出通过使用 softmax 激活函数的 Dense 层进行传递，以预测后续单词的分布
  8. outputs = layers.Dense(VOCAB_SIZE, activation="softmax")(x)
  9. # 模型以单词符号序列作为输入，并输出预测的后续单词分布。还返回了 Transformer 块的输出，以便检查模型中注意力机制的作用
  10. gpt = models.Model(inputs=inputs, outputs=[outputs, attention_scores])
  11. # 模型使用 SparseCategoricalCrossentropy 损失函数编译并训练
  12. gpt.compile("adam", loss=[losses.SparseCategoricalCrossentropy(), None])
  13. print(gpt.summary())
  14. gpt.fit(train_ds,epochs=EPOCHS,)
复制代码
6. GPT 分析

训练 GPT 模型后，就可以利用 GPT 天生长文本，还可以获取 TransformerBlock 输出的注意力权重，以了解 Transformer 在天生过程中差异位置探求信息的方式。
6.1 天生文本

我们可以通过以下过程天生新文本：

从网络输出的一组概率中举行抽样，使文本天生过程具有随机性，而不是确定性的。
为了控制采样过程简直定性水平，重用 LSTM 文本天生中的 TextGenerator 类，其利用温度参数来指定采样过程中简直定性水平，利用两个差异的温度值对比天生结果。温度为 1.0 的天生文本比温度为 0.5 的样本具有更高的随机性，因此正确率较低。由于模型从方差较大的概率分布中举行抽样，因此利用温度为 1.0 天生多个样本将具有更多的多样性。
6.2 注意力分数

我们还可以令模型输出，在决定句子中的下一个单词时，每个单词的注意力分数。TransformerBlock 输出每个注意力头的注意力权重，该权重是句子中前面单词的 softmax 分布。
为了举行说明，下图表现了对于三个差异的输入，具有最高概率的前五个符号，以及相对于前面每个单词，两个注意力头的平均注意力。根据其注意力分数对前面的单词举行着色，较深的颜色表现对该单词的注意力更高。

以这种方式查看网络，可以正确地了解网络从那边获取信息，以便对随后的每个单词做出正确猜测。通过修改输入，观察是否可以使模型关注到句子中相距较远的单词，以充分证实基于注意力的模型相对于传统的循环模型更强大。
小结

在本节中，我们先容了 Transformer 模型架构，并构建了一个 GPT 模型，以实现文本天生。GPT 利用了注意力机制，消除了对循环层(如好坏时记忆网络)的需求。注意力机制类似于一个信息检索系统，利用查询、键和值来决定从每个输入符号中提取多少信息。
系列链接

AIGC实战——天生模型简介
AIGC实战——深度学习 (Deep Learning, DL)
AIGC实战——卷积神经网络(Convolutional Neural Network, CNN)
AIGC实战——自编码器(Autoencoder)
AIGC实战——变分自编码器(Variational Autoencoder, VAE)
AIGC实战——利用变分自编码器天生面部图像
AIGC实战——天生对抗网络(Generative Adversarial Network, GAN)
AIGC实战——WGAN(Wasserstein GAN)
AIGC实战——条件天生对抗网络(Conditional Generative Adversarial Net, CGAN)
AIGC实战——自回归模型(Autoregressive Model)
AIGC实战——改进循环神经网络
AIGC实战——像素卷积神经网络(PixelCNN)
AIGC实战——归一化流模型(Normalizing Flow Model)
AIGC实战——能量模型(Energy-Based Model)
AIGC实战——扩散模型(Diffusion Model)

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4