GPT：Transformer的专精产品

目录
1.  前言
2. GPT与Transformer的对比
2.1 Transformer架构
2.2 GPT架构
2.3 重要区别
3. GPT模型架构详解与代码实例
3.1 嵌入层
3.2 多头注意力机制
3.3 完整的GPT模型
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的输入首先经过词嵌入和位置嵌入，将输入序列转换为连续的向量表示。位置嵌入用于捕捉序列中的位置信息。

1. import torch
2. import torch.nn as nn
4. class GPT_Embedding(nn.Module):
5.     def __init__(self, maxlen, d_model, vocab_size):
6.         super(GPT_Embedding, self).__init__()
7.         self.positionEmbedding = nn.Embedding(maxlen, d_model)
8.         self.wordEmbedding = nn.Embedding(vocab_size, d_model)
10.     def forward(self, x):
11.         position = torch.arange(0, x.size(1), dtype=torch.long, device=x.device)
12.         position = self.positionEmbedding(position)
13.         x = self.wordEmbedding(x)
14.         return x + position

复制代码

x：是输入的词索引张量（通常是二维张量，形状为[batch_size, seq_length]） 
3.2 多头注意力机制

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

1. class GPT_Attention(nn.Module):
2.     def __init__(self, d_model, n_head, d_ff, dropout):
3.         super(GPT_Attention, self).__init__()
4.         self.d_model = d_model
5.         self.n_head = n_head
6.         self.d_ff = d_ff
7.         self.dropout = dropout
8.         self.wq = nn.Linear(d_model, d_model)
9.         self.wk = nn.Linear(d_model, d_model)
10.         self.wv = nn.Linear(d_model, d_model)
11.         self.attn = nn.MultiheadAttention(d_model, n_head, dropout=dropout, batch_first=True)
12.         self.layer_norm1 = nn.LayerNorm(d_model)
13.         self.layer_norm2 = nn.LayerNorm(d_model)
14.         self.feed_forward = nn.Sequential(
15.             nn.Linear(d_model, d_ff),
16.             nn.Dropout(dropout),
17.             nn.Tanh(),
18.             nn.Linear(d_ff, d_model),
19.             nn.Dropout(dropout),
20.         )
22.     def forward(self, x):
23.         Q = self.wq(x)
24.         K = self.wk(x)
25.         V = self.wv(x)
26.         attn_mask = torch.triu(torch.ones(x.shape[1], x.shape[1]), diagonal=1).bool()
27.         attn_mask = attn_mask.to(x.device)
28.         attn_output, attn_weights = self.attn(Q, K, V, attn_mask=attn_mask, need_weights=True)
29.         attn_output = attn_output + x  # 残差连接
30.         attn_output = self.layer_norm1(attn_output)
31.         attn_output = attn_output + self.feed_forward(attn_output)
32.         attn_output = self.layer_norm2(attn_output)
33.         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模型。

1. class GPT(nn.Module):
2.     def __init__(self, config):
3.         super(GPT, self).__init__()
4.         self.embedding = GPT_Embedding(
5.             maxlen=config["maxlen"],
6.             d_model=config["d_model"],
7.             vocab_size=config["vocab_size"]
8.         )
9.         self.transformer_blocks = nn.ModuleList([
10.             GPT_Attention(
11.                 d_model=config["d_model"],
12.                 n_head=config["n_head"],
13.                 d_ff=config["d_ff"],
14.                 dropout=config["dropout"]
15.             ) for _ in range(config["n_layer"])
16.         ])
17.         self.fc_out = nn.Linear(config["d_model"], config["vocab_size"])
19.     def forward(self, x):
20.         x = self.embedding(x)
21.         for block in self.transformer_blocks:
22.             x = block(x)
23.         return self.fc_out(x)

复制代码

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

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

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