AIGC实战——GPT(Generative Pre-trained Transformer)

AIGC实战——GPT

• • 0. 前言
  • 1. GPT 简介
  • 2. 葡萄酒评论数据集
  • 3. 注意力机制
  • • 3.1 查询、键和值
    • 3.2 多头注意力
    • 3.3 因果掩码
  • 4. Transformer
  • • 4.1 Transformer 块
    • 4.2 位置编码
  • 5. 训练GPT
  • 6. GPT 分析
  • • 6.1 生成文本
    • 6.2 注意力分数
  • 小结
  • 系列链接

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 训练生成模型中所用的数据准备步骤相同：

• 加载数据并创建一个包含所有葡萄酒文本描述的字符串列表
• 用空格分隔标点符号，以便每个标点符号被视为一个单独的单词
• 通过 TextVectorization 层将字符串进行分词，并将每个字符串填充/截断为固定长度
• 创建训练集，其中输入是分词后的文本字符串，输出是将相同字符串向后移动一个符号的字符串

3. 注意力机制

理解 GPT 工作原理的第一步是理解注意力机制 (attention mechanism)，注意力机制使得 Transformer 架构在语言建模方面与循环神经网络有所不同。理解了注意力机制后，便能了解如何在 Transformer 架构(如 GPT )中使用注意力机制。
当我们写作时，句子中的下一个单词受到已经写完的其他单词的影响。例如，假设以以下方式开始一个句子：

"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” 的嵌入传递到权重矩阵 中，从维度 变换为维度 ，得到了查询。
键向量 (key, K) 是句子中每个单词的表示，可以将其视为每个单词可以帮助完成的预测任务的贡献。它们与查询的产生方式类似，通过将每个嵌入传递到权重矩阵 中，将每个向量的维度从 变换为 ，键和查询的长度相同。
在注意力头中，使用每对向量 () 之间的点积将每个键与查询进行比较(这就是键和查询必须具有相同的长度的原因)。键/查询对的点积结果数值越高，键与查询的相关度就越强，因此允许它对注意力头的输出做出更大的贡献。得到的向量乘以 ，以保持向量和的方差稳定(大约等于 1)，并应用 softmax 函数确保贡献总和为 1，这便是注意力权重向量。
值向量 (value, V) 也是句子中单词的表示，可以将其视为每个单词的未加权贡献。通过将每个嵌入传递到权重矩阵 中，将每个向量的维度从 变换为 ，得到值向量。需要注意的是，值向量不一定与键和查询具有相同的长度(但通常为简单起见，使用相同长度)。
值向量乘以注意力权重，得到给定 、 和 的注意力：

为了从注意力头获得最终输出向量，将注意力进行求和，得到长度为 的向量。这个上下文向量捕捉了句子中的单词对于预测接在 too 之后的词的任务的共同意见。

3.2 多头注意力

在 Keras 中，可以构建 MultiHeadAttention 层，该层将多个注意力头的输出连接起来构成多头注意力 (Multihead Attention)，允许每个头学习不同的注意力机制，以便整个层可以学习更复杂的关系。
连接后的输出通过最终的权重矩阵 进行投影，将向量投影到期望的输出维度上。在本节下，输出维度与查询的输入维度相同 ()，以便可以将层按顺序堆叠在一起。下图显示了 MultiHeadAttention 层输出的构建方式。

在 Keras 中创建 MultiHeadAttention 层：

layers.MultiHeadAttention(
    # 此多头注意力层有四个注意力头
    num_heads = 4,
    # 键(和查询)是长度为 128 的向量
    key_dim = 128,
    # 值(也是每个头的输出)是长度为 64 的向量
    value_dim = 64,
    # 输出向量的长度为 256
    output_shape = 256
)

3.3 因果掩码

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

如果没有这个掩码，GPT 模型将能够完美地猜出句子中的下一个单词，因为它将使用来自单词本身的键作为一个特征。使用 Keras 创建因果掩码，下图显示了 Numpy 形式的结果数组(为了与图相匹配，将结果数组进行了转置)。

def causal_attention_mask(batch_size, n_dest, n_src, dtype):
    i = tf.range(n_dest)[:, None]
    j = tf.range(n_src)
    m = i >= j - n_src + n_dest
    mask = tf.cast(m, dtype)
    mask = tf.reshape(mask, [1, n_dest, n_src])
    mult = tf.concat(
        [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)], 0
    )
    return tf.tile(mask, mult)

print(np.transpose(causal_attention_mask(1, 10, 10, dtype=tf.int32)[0]))

因果掩码仅在解码器 Transformer(如 GPT )中需要，在这些模型中，任务是根据先前的符号顺序生成符号，在训练期间掩码掉未来的符号是至关重要的。
其他类型的 Transformer (例如编码器 Transformer )不需要因果掩码，因为它们不是通过预测下一个符号来训练的。例如，Google 的 BERT 在给定句子中预测待填空的单词，因此它可以使用该词前后的上下文。
Transformer 中的多头注意力机制中，层的可学习参数仅由每个注意力头的三个权重矩阵 (、、) 和一个用于重塑输出的权重矩阵 () 组成，在多头注意力层中完全没有卷积或循环机制。
下一节中，我们将介绍如何使用多头注意力层构建 Transformer 块。

4. Transformer

4.1 Transformer 块

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

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

最后，在 Transformer 块中包含了一组前馈(全连接)层( Feed-forward layers )，以使组件能够在网络中深入提取更高级别的特征。
使用 Keras 实现一个 Transformer 块。

class TransformerBlock(layers.Layer):
    # 在初始化函数中定义构成 TransformerBlock 层的子层
    def __init__(self, num_heads, key_dim, embed_dim, ff_dim, dropout_rate=0.1):
        super(TransformerBlock, self).__init__()
        self.num_heads = num_heads
        self.key_dim = key_dim
        self.embed_dim = embed_dim
        self.ff_dim = ff_dim
        self.dropout_rate = dropout_rate
        self.attn = layers.MultiHeadAttention(
            num_heads, key_dim, output_shape=embed_dim
        )
        self.dropout_1 = layers.Dropout(self.dropout_rate)
        self.ln_1 = layers.LayerNormalization(epsilon=1e-6)
        self.ffn_1 = layers.Dense(self.ff_dim, activation="relu")
        self.ffn_2 = layers.Dense(self.embed_dim)
        self.dropout_2 = layers.Dropout(self.dropout_rate)
        self.ln_2 = layers.LayerNormalization(epsilon=1e-6)

    def call(self, inputs):
        input_shape = tf.shape(inputs)
        batch_size = input_shape[0]
        seq_len = input_shape[1]
        # 创建因果掩码，以隐藏查询中未来的键
        causal_mask = causal_attention_mask(
            batch_size, seq_len, seq_len, tf.bool
        )
        # 创建多头注意力层，并指定注意力掩码
        attention_output, attention_scores = self.attn(
            inputs,
            inputs,
            attention_mask=causal_mask,
            return_attention_scores=True,
        )
        attention_output = self.dropout_1(attention_output)
        # 第一个 add 和归一化层
        out1 = self.ln_1(inputs + attention_output)
        # 前馈层
        ffn_1 = self.ffn_1(out1)
        ffn_2 = self.ffn_2(ffn_1)
        # 第二个 add 和归一化层
        ffn_output = self.dropout_2(ffn_2)
        return (self.ln_2(out1 + ffn_output), attention_scores)

4.2 位置编码

在训练 GPT 模型之前，还有一个最后一步需要处理。在多头注意力层中，并没有关注键的顺序。每个键与查询之间的点积是并行计算的，而非像循环神经网络那样顺序计算。这样可以并行化处理以提高效率，但也带来了一个问题，因为我们需要注意力层能够考虑文本的上下文信息，例如，针对以下两个句子预测不同的输出：

The dog looked at the boy and … (barked?)
The boy looked at the dog and … (smiled?)

为了解决这个问题，在创建初始的 Transformer 块的输入时，我们使用一种称为位置编码 (positional encoding) 的技术。我们不仅使用符号嵌入 (token embedding) 来编码每个符号，还使用位置嵌入 (position embedding) 来编码符号的位置。
符号嵌入使用标准的嵌入层将每个符号转换为一个可学习向量。我们可以使用相同的方式创建位置编码，使用标准的嵌入层将每个整数位置转换为一个可学习向量。虽然 GPT 使用嵌入层来嵌入位置信息，但原始 Transformer 论文使用三角函数。
为了构建联合的符号-位置编码，将符号嵌入添加到位置嵌入中，如下图所示。这样，就可以在一个向量中同时捕捉序列中每个词的含义和位置信息。

使用 Keras 定义 TokenAndPositionEmbedding 层：

class TokenAndPositionEmbedding(layers.Layer):
    def __init__(self, max_len, vocab_size, embed_dim):
        super(TokenAndPositionEmbedding, self).__init__()
        self.max_len = max_len
        self.vocab_size = vocab_size
        self.embed_dim = embed_dim
        # 符号使用 Embedding 层获取嵌入
        self.token_emb = layers.Embedding(
            input_dim=vocab_size, output_dim=embed_dim
        )
        # 符号的位置同样使用 Embedding 层获取嵌入
        self.pos_emb = layers.Embedding(input_dim=max_len, output_dim=embed_dim)

    def call(self, x):
        maxlen = tf.shape(x)[-1]
        positions = tf.range(start=0, limit=maxlen, delta=1)
        positions = self.pos_emb(positions)
        x = self.token_emb(x)
        # TokenAndPositionEmbedding 层的输出是符号嵌入和位置嵌入之和
        return x + positions

5. 训练GPT

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

使用 Keras 实现此架构：

# 用 0 填充输入
inputs = layers.Input(shape=(None,), dtype=tf.int32)
# 文本使用 TokenAndPositionEmbedding 层获取嵌入
x = TokenAndPositionEmbedding(MAX_LEN, VOCAB_SIZE, EMBEDDING_DIM)(inputs)
# 嵌入通过 TransformerBlock 进行传递
x, attention_scores = TransformerBlock(N_HEADS, KEY_DIM, EMBEDDING_DIM, FEED_FORWARD_DIM)(x)
# 转换后的输出通过使用 softmax 激活函数的 Dense 层进行传递，以预测后续单词的分布
outputs = layers.Dense(VOCAB_SIZE, activation="softmax")(x)
# 模型以单词符号序列作为输入，并输出预测的后续单词分布。还返回了 Transformer 块的输出，以便检查模型中注意力机制的作用
gpt = models.Model(inputs=inputs, outputs=[outputs, attention_scores])
# 模型使用 SparseCategoricalCrossentropy 损失函数编译并训练
gpt.compile("adam", loss=[losses.SparseCategoricalCrossentropy(), None])
print(gpt.summary())
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)