GPT：Transformer的专精产品

[1. 前言](#1. 前言)

[2. GPT与Transformer的对比](#2. GPT与Transformer的对比)

[2.1 Transformer架构](#2.1 Transformer架构)

[2.2 GPT架构](#2.2 GPT架构)

[2.3 主要区别](#2.3 主要区别)

[3. GPT模型架构详解与代码实例](#3. GPT模型架构详解与代码实例)

[3.1 嵌入层](#3.1 嵌入层)

[3.2 多头注意力机制](#3.2 多头注意力机制)

[3.3 完整的GPT模型](#3.3 完整的GPT模型)

[4. 总结](#4. 总结)

1. 前言

GPT（Generative Pre-trained Transformer）是一种基于Transformer架构的生成式预训练模型，由OpenAI开发。它通过无监督学习的方式进行预训练，然后通过微调适应特定任务。GPT的核心结构是Transformer的解码器部分，但对其进行了一些改动，例如只保留了掩码多头注意力机制。

因为有Transformer的基础，本文有很多省略，Transformer架构可以去看看：

《Transformer模型解析与实例：搭建一个自己的预测语言模型》

2. GPT与Transformer的对比

2.1 Transformer架构

Transformer由编码器和解码器组成，编码器用于处理输入序列，解码器用于生成输出序列。编码器包含多头自注意力机制和前馈神经网络，而解码器则包含多头自注意力机制、掩码多头注意力机制和前馈神经网络。

2.2 GPT架构

GPT基于Transformer的解码器部分，但只保留了掩码多头注意力机制。这种设计使得GPT能够专注于生成任务，每个位置的词只能依赖于前面的词，从而实现自回归生成。

2.3 主要区别

结构简化：GPT只使用了解码器部分，而Transformer包含编码器和解码器。
掩码机制：GPT使用掩码多头注意力机制，确保每个词只能看到前面的词。
生成能力：GPT专注于生成任务，而Transformer适用于多种任务（如翻译、问答等）。

3. GPT模型架构详解与代码实例

3.1 嵌入层

GPT的输入首先经过词嵌入和位置嵌入，将输入序列转换为连续的向量表示。位置嵌入用于捕捉序列中的位置信息。

python 复制代码

import torch
import torch.nn as nn

class GPT_Embedding(nn.Module):
    def __init__(self, maxlen, d_model, vocab_size):
        super(GPT_Embedding, self).__init__()
        self.positionEmbedding = nn.Embedding(maxlen, d_model)
        self.wordEmbedding = nn.Embedding(vocab_size, d_model)

    def forward(self, x):
        position = torch.arange(0, x.size(1), dtype=torch.long, device=x.device)
        position = self.positionEmbedding(position)
        x = self.wordEmbedding(x)
        return x + position

x：是输入的词索引张量（通常是二维张量，形状为[batch_size, seq_length]）

3.2 多头注意力机制

多头注意力机制通过多个注意力头捕捉输入序列中不同位置的依赖关系。GPT使用掩码多头注意力机制，确保每个位置只能依赖于前面的词。

python 复制代码

class GPT_Attention(nn.Module):
    def __init__(self, d_model, n_head, d_ff, dropout):
        super(GPT_Attention, self).__init__()
        self.d_model = d_model
        self.n_head = n_head
        self.d_ff = d_ff
        self.dropout = dropout
        self.wq = nn.Linear(d_model, d_model)
        self.wk = nn.Linear(d_model, d_model)
        self.wv = nn.Linear(d_model, d_model)
        self.attn = nn.MultiheadAttention(d_model, n_head, dropout=dropout, batch_first=True)
        self.layer_norm1 = nn.LayerNorm(d_model)
        self.layer_norm2 = nn.LayerNorm(d_model)
        self.feed_forward = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.Dropout(dropout),
            nn.Tanh(),
            nn.Linear(d_ff, d_model),
            nn.Dropout(dropout),
        )

    def forward(self, x):
        Q = self.wq(x)
        K = self.wk(x)
        V = self.wv(x)
        attn_mask = torch.triu(torch.ones(x.shape[1], x.shape[1]), diagonal=1).bool()
        attn_mask = attn_mask.to(x.device)
        attn_output, attn_weights = self.attn(Q, K, V, attn_mask=attn_mask, need_weights=True)
        attn_output = attn_output + x  # 残差连接
        attn_output = self.layer_norm1(attn_output)
        attn_output = attn_output + self.feed_forward(attn_output)
        attn_output = self.layer_norm2(attn_output)
        return attn_output

d_ff：前馈神经网络的隐藏层大小。

1. self.layer_norm1 = nn.LayerNorm(d_model)

定义第一个层归一化层：

层归一化用于稳定训练过程，确保输入的分布稳定。
这里对d_model维度进行归一化。

2. self.feed_forward = nn.Sequential(...)

定义前馈神经网络：

nn.Linear(d_model, d_ff)：第一个线性变换层，将输入维度扩展到d_ff。
nn.Dropout(dropout)：应用丢弃，防止过拟合。
nn.Tanh()：激活函数，引入非线性。
nn.Linear(d_ff, d_model)：第二个线性变换层，将维度缩小回d_model。
nn.Dropout(dropout)：再次应用丢弃。

3. attn_mask = torch.triu(torch.ones(x.shape[1], x.shape[1]), diagonal=1).bool()

这行代码生成一个掩码矩阵，用于确保每个位置的词只能看到前面的词：

torch.ones(x.shape[1], x.shape[1])：生成一个形状为[seq_length, seq_length]的全1矩阵。
torch.triu(..., diagonal=1)：提取矩阵的上三角部分（对角线以上的部分），并将对角线以下的部分设置为0。
.bool()：将矩阵转换为布尔类型，True表示需要掩码的位置，False表示不需要掩码的位置。

4. attn_output, attn_weights = self.attn(Q, K, V, attn_mask=attn_mask, need_weights=True)

这行代码调用多头注意力机制：

Q、K、V：分别是查询向量、键向量和值向量。
attn_mask：掩码矩阵，用于确保每个位置的词只能依赖于前面的词。
need_weights=True：表示需要返回注意力权重。
attn_output：多头注意力的输出。
attn_weights：注意力权重矩阵。

可以看到掩码多头注意力和前馈神经网络都需要残差连接，和Transformer类似。

3.3 完整的GPT模型

将嵌入层、多头注意力机制和前馈网络组合起来，形成完整的GPT模型。

python 复制代码

class GPT(nn.Module):
    def __init__(self, config):
        super(GPT, self).__init__()
        self.embedding = GPT_Embedding(
            maxlen=config["maxlen"],
            d_model=config["d_model"],
            vocab_size=config["vocab_size"]
        )
        self.transformer_blocks = nn.ModuleList([
            GPT_Attention(
                d_model=config["d_model"],
                n_head=config["n_head"],
                d_ff=config["d_ff"],
                dropout=config["dropout"]
            ) for _ in range(config["n_layer"])
        ])
        self.fc_out = nn.Linear(config["d_model"], config["vocab_size"])

    def forward(self, x):
        x = self.embedding(x)
        for block in self.transformer_blocks:
            x = block(x)
        return self.fc_out(x)

创建一个包含多个GPT_Attention模块的列表，每个模块都按照config中的参数进行初始化。这些模块将按照顺序应用于输入数据，逐步提取和处理序列中的信息。

4. 总结

GPT模型通过基于Transformer解码器的架构，实现了强大的文本生成能力。通过掩码多头注意力机制，GPT能够专注于生成任务，每个位置的词只能依赖于前面的词。我是橙色小博，关注我，一起在人工智能领域学习进步！