【人工智能之大模型】GPT系列（GPT-1 到 GPT-2 和 GPT-3（以及后续 GPT-4 的概念性改进））模型是如何演进的？（一）

985小水博一枚呀

1039人浏览 · 2025-03-23 13:30:00

985小水博一枚呀 · 2025-03-23 13:30:00 发布

【人工智能之大模型】GPT系列（GPT-1 到 GPT-2 和 GPT-3（以及后续 GPT-4 的概念性改进））模型是如何演进的？（一）

文章目录

【人工智能之大模型】GPT系列（GPT-1 到 GPT-2 和 GPT-3（以及后续 GPT-4 的概念性改进））模型是如何演进的？（一）
1. GPT 系列模型演进概述
2. 代码示例：简化版 GPT 模型

欢迎宝子们点赞、关注、收藏！欢迎宝子们批评指正！
祝所有的硕博生都能遇到好的导师！好的审稿人！好的同门！顺利毕业！

大多数高校硕博生毕业要求需要参加学术会议，发表EI或者SCI检索的学术论文会议论文。详细信息可关注VX “学术会议小灵通”或参考学术信息专栏：https://blog.csdn.net/gaoxiaoxiao1209/article/details/145231978

1. GPT 系列模型演进概述

GPT-1 (2018)

架构：基于 Transformer 解码器（decoder-only），采用自回归语言模型训练。
参数规模：约 1.17 亿参数。
训练目标：下一词预测，通过预训练获得通用语言表示，然后在下游任务上微调。
创新点：首次提出预训练-微调范式在自然语言处理任务中的有效性。

GPT-2 (2019)

规模提升：参数从 1.17 亿扩展到 15 亿甚至 17 亿参数（不同版本），采用更大规模的数据集。
生成能力：生成文本更流畅、连贯，展现出较强的常识推理能力和开放域对话能力。
无监督学习：完全通过无监督学习完成预训练，并在多项任务中实现“零样本”迁移。

GPT-3 (2020)

大幅扩展：参数规模达到 1750 亿参数，模型容量和知识储备大幅提升。
Few-shot 能力：在极少或零样本情况下，通过提示（prompting）即可完成各种任务；展现出较强的泛化能力。
技术挑战：大规模训练带来计算资源和数据清洗、模型优化等更高要求，同时需要解决模型一致性、偏见等问题。

GPT-4 (2023)

多模态扩展：在 GPT-3 基础上，进一步整合了图像、文本等多模态信息。
性能和安全：在生成文本的准确性、连贯性以及安全性上都有提升；同时在用户交互体验和应用普适性上有所改进。

总体来说，GPT 系列模型保持了相同的基本架构（解码器式 Transformer），但通过不断扩大模型规模、改进训练策略和数据集，使得生成能力和下游应用表现不断提升。

2. 代码示例：简化版 GPT 模型

下面的代码示例展示了一个简化的 GPT 模型，包括词嵌入、位置编码、多个 Transformer Block 以及输出层。通过注释说明各部分的功能，也会在注释中提及 GPT-1、GPT-2、GPT-3 的演进对超参数选择的影响。

import torch
import torch.nn as nn
import torch.nn.functional as F

# ---------------------------
# Transformer Block（简化版）
# ---------------------------
class TransformerBlock(nn.Module):
    def __init__(self, d_model, nhead, dim_feedforward, dropout=0.1):
        """
        d_model: 隐藏层维度
        nhead: 多头注意力头数
        dim_feedforward: 前馈网络内部维度
        dropout: dropout 概率
        """
        super(TransformerBlock, self).__init__()
        # 多头自注意力层
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        # 前馈网络
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.linear2 = nn.Linear(dim_feedforward, d_model)
        # LayerNorm 用于残差连接后的归一化
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)
    
    def forward(self, src, src_mask=None):
        # 自注意力计算，src: [seq_len, batch_size, d_model]
        attn_output, _ = self.self_attn(src, src, src, attn_mask=src_mask)
        # 残差连接与归一化
        src = self.norm1(src + self.dropout(attn_output))
        # 前馈网络计算
        ff_output = self.linear2(self.dropout(F.relu(self.linear1(src))))
        src = self.norm2(src + self.dropout(ff_output))
        return src

# ---------------------------
# GPT 模型（简化版）
# ---------------------------
class GPT(nn.Module):
    def __init__(self, vocab_size, d_model=512, nhead=8, num_layers=6, dim_feedforward=2048, max_seq_length=128, dropout=0.1):
        """
        vocab_size: 词汇表大小
        d_model: 隐藏层维度（GPT-1 约512，GPT-2 和 GPT-3 会更大）
        nhead: 多头注意力头数
        num_layers: Transformer 层数（GPT-1 较少，GPT-2、GPT-3 较多）
        dim_feedforward: 前馈网络内部维度
        max_seq_length: 最大序列长度
        dropout: dropout 概率
        """
        super(GPT, self).__init__()
        # 词嵌入层，将词 ID 映射为 d_model 维向量
        self.token_embedding = nn.Embedding(vocab_size, d_model)
        # 位置编码：这里使用可学习的位置编码
        self.pos_embedding = nn.Parameter(torch.zeros(max_seq_length, d_model))
        # 定义 Transformer 解码器块
        self.layers = nn.ModuleList([
            TransformerBlock(d_model, nhead, dim_feedforward, dropout)
            for _ in range(num_layers)
        ])
        # 输出投影层，将隐层映射到词汇表大小，输出 logits
        self.fc_out = nn.Linear(d_model, vocab_size)
        self.dropout = nn.Dropout(dropout)
    
    def forward(self, input_ids):
        """
        input_ids: [batch_size, seq_length] 输入的 token 序列
        返回：
            logits: [batch_size, seq_length, vocab_size]
        """
        batch_size, seq_length = input_ids.size()
        # 词嵌入：得到 [batch_size, seq_length, d_model]
        token_emb = self.token_embedding(input_ids)
        # 位置编码：取前 seq_length 个位置编码，并扩展为 [1, seq_length, d_model]
        pos_emb = self.pos_embedding[:seq_length, :].unsqueeze(0)
        # 嵌入相加，并转置为 [seq_length, batch_size, d_model] 以符合 nn.MultiheadAttention 的要求
        x = self.dropout(token_emb + pos_emb).transpose(0, 1)
        
        # 构造因果掩码，确保自注意力层中每个位置只能看到当前位置之前的信息
        causal_mask = torch.triu(torch.ones(seq_length, seq_length) * float('-inf'), diagonal=1).to(x.device)
        
        # 依次通过每一层 Transformer Block
        for layer in self.layers:
            x = layer(x, src_mask=causal_mask)
        
        # 转置回来 [batch_size, seq_length, d_model]
        x = x.transpose(0, 1)
        # 输出层：得到 logits
        logits = self.fc_out(x)
        return logits

# ---------------------------
# 示例：使用 GPT 模型
# ---------------------------
if __name__ == '__main__':
    # 超参数设定
    vocab_size = 5000  # 示例词汇表大小
    d_model = 512      # GPT-1 常用 512 维，GPT-2、GPT-3 会更大
    nhead = 8
    num_layers = 6     # GPT-1 可能为 6-12 层，后续模型层数更多
    dim_feedforward = 2048
    max_seq_length = 128
    
    model = GPT(vocab_size, d_model, nhead, num_layers, dim_feedforward, max_seq_length)
    # 模拟输入：批次大小为 2，序列长度为 10
    input_ids = torch.randint(0, vocab_size, (2, 10))
    logits = model(input_ids)
    print("Logits shape:", logits.shape)  # 输出应为 [2, 10, vocab_size]