GPT1.0 和 GPT2.0 的联系与区别

🕗 发布于 2024-11-22 06:06 语言模型 gpt chatgpt nlp

随着自然语言处理技术的飞速发展，OpenAI 提出的 GPT 系列模型成为了生成式预训练模型的代表。作为 GPT 系列的两代代表，GPT-1 和 GPT-2 虽然在架构上有着继承关系，但在设计理念和性能上有显著的改进。本文将从模型架构、参数规模、训练数据和实际能力等方面分析 GPT-1 和 GPT-2 的联系与区别。

一、GPT-1 和 GPT-2 的基本联系

相同的核心架构：基于 Transformer 的解码器结构
- GPT-1 和 GPT-2 都采用了 Transformer 架构中的解码器部分，取消了编码器部分。这种设计使得模型专注于自回归任务，即通过给定前文预测下一个词。
- 两者均使用多头自注意力机制和前馈网络相结合的模块堆叠。
语言建模目标一致
- 两代模型的训练目标都是无监督语言建模（Unsupervised Language Modeling），以最大化给定文本序列的似然概率为优化目标。
- 使用左到右的单向生成方式，从序列的开头逐词预测，适用于语言生成任务。
位置嵌入（Positional Embedding）
- 两代模型均使用了位置嵌入，将词汇嵌入（Token Embedding）与位置嵌入相加后作为 Transformer 的输入。
残差连接与 LayerNorm
- 残差连接（Residual Connection）和层归一化（Layer Normalization）被广泛用于提升梯度流动和训练稳定性。

二、GPT-1 和 GPT-2 的主要区别

1. 模型规模

GPT-2 的显著改进在于模型规模的扩展：

GPT-1：只有一个版本，参数规模为 1.1 亿（110M），包含 12 层 Transformer 解码器，每层的隐藏状态维度为 768。
GPT-2：提供了多个版本，最大参数规模达到 15 亿（1.5B），包含 48 层 Transformer 解码器，每层的隐藏状态维度为 1600，注意力头数从 12 增加到 16。

2. 上下文窗口长度

GPT-1 的最大上下文长度为 512。
GPT-2 扩展到了 1024，使得模型可以捕获更长的上下文依赖关系，提升了生成的连贯性和逻辑性。

3. 训练数据集

GPT-1：训练数据规模较小，主要来自书籍数据集（BooksCorpus）等，包含约 5GB 的文本。
GPT-2：大幅扩展训练数据，使用了一个名为 WebText 的数据集，包含约 40GB 的高质量互联网文本。WebText 通过过滤低质量内容（如广告和代码）优化了数据质量。
这种数据规模和多样性的提升，让 GPT-2 的泛化能力远超 GPT-1。

4. LayerNorm 的位置

GPT-1 使用了前置 LayerNorm（Pre-Norm），即将 LayerNorm 放在子模块的输入部分。
GPT-2 改为后置 LayerNorm（Post-Norm），即将 LayerNorm 放在子模块的输出部分。后置 LayerNorm 改善了梯度流动问题，提升了模型的训练稳定性。

5. 语言生成能力

GPT-2 在语言生成的连贯性、上下文一致性和逻辑性方面大幅超越 GPT-1，尤其是在长文本生成时表现尤为突出。
GPT-2 具备更强的多任务能力，即使没有专门的微调，也能解决翻译、问答等多种任务（零样本和少样本学习）。

6. 训练优化

GPT-2 引入了更高效的优化技术，比如改进了学习率调度策略（线性学习率热身和余弦衰减）、更少的 Dropout 使用等。

三、GPT-1 和 GPT-2 的实际意义

1. GPT-1：验证 GPT 架构的有效性

GPT-1 是生成式预训练模型（Generative Pre-trained Transformer）的首次实践，验证了基于无监督预训练的 Transformer 架构在自然语言处理任务中的潜力。
其提出了“预训练 + 微调”的通用框架，为后续模型的快速发展奠定了基础。

2. GPT-2：大规模模型的潜力

GPT-2 的成功揭示了“更大模型 + 更多数据”在提升自然语言处理能力上的重要性。
它的强大能力表明，模型规模的扩大与数据质量的提升可以显著提高模型在语言生成和多任务学习中的表现。

3. 技术传播与影响

GPT-1 的问世将注意力吸引到生成式语言模型领域，而 GPT-2 的发布则推动了行业对大规模预训练模型的关注，直接影响了后续 GPT-3、ChatGPT 等更强大的模型发展。

四、总结

GPT-1 和 GPT-2 作为两代生成式预训练模型，既有紧密的联系，也展现出明显的区别：

特性	GPT-1	GPT-2
参数规模	1.1 亿	15 亿
Transformer 层数	12 层	48 层（大模型）
隐藏层维度	768	1600
上下文长度	512	1024
训练数据集	5GB	40GB
LayerNorm 位置	前置	后置
生成质量	一般	优秀

GPT-1 提供了理论框架，GPT-2 则通过更大的规模、更优的数据和更精细的优化将这种架构的潜力发挥到了极致。两者的进化过程体现了深度学习领域中“大规模预训练模型”的发展思路，也为后续 GPT 系列的发展铺平了道路。

五、参考代码（不完整，仅供理解）

import torch
import torch.nn as nn
import torch.optim as optim


class GPT1Layer(nn.Module):
    """GPT-1 的 Transformer 子模块，使用前置 LayerNorm"""

    def __init__(self, embed_size, num_heads):
        super(GPT1Layer, self).__init__()
        self.ln = nn.LayerNorm(embed_size)
        self.attn = nn.MultiheadAttention(embed_size, num_heads)
        self.ffn = nn.Sequential(
            nn.Linear(embed_size, 4 * embed_size),
            nn.GELU(),
            nn.Linear(4 * embed_size, embed_size)
        )

    def forward(self, x):
        # 前置 LayerNorm + 注意力
        x_norm = self.ln(x)
        attn_out, _ = self.attn(x_norm, x_norm, x_norm)
        x = x + attn_out  # 残差连接

        # 前置 LayerNorm + 前馈网络
        x_norm = self.ln(x)
        ffn_out = self.ffn(x_norm)
        x = x + ffn_out  # 残差连接

        return x


class GPT2Layer(nn.Module):
    """GPT-2 的 Transformer 子模块，使用后置 LayerNorm"""

    def __init__(self, embed_size, num_heads):
        super(GPT2Layer, self).__init__()
        self.attn = nn.MultiheadAttention(embed_size, num_heads)
        self.ln1 = nn.LayerNorm(embed_size)
        self.ffn = nn.Sequential(
            nn.Linear(embed_size, 4 * embed_size),
            nn.GELU(),
            nn.Linear(4 * embed_size, embed_size)
        )
        self.ln2 = nn.LayerNorm(embed_size)

    def forward(self, x):
        # 注意力 + 残差连接 + 后置 LayerNorm
        attn_out, _ = self.attn(x, x, x)
        x = x + attn_out
        x = self.ln1(x)

        # 前馈网络 + 残差连接 + 后置 LayerNorm
        ffn_out = self.ffn(x)
        x = x + ffn_out
        x = self.ln2(x)

        return x


class GPT(nn.Module):
    """通用 GPT 模型，允许指定 LayerNorm 逻辑"""

    def __init__(self, vocab_size, embed_size, num_heads, num_layers, max_len, layer_cls):
        super(GPT, self).__init__()
        self.embed = nn.Embedding(vocab_size, embed_size)
        self.pos_embed = nn.Embedding(max_len, embed_size)
        self.layers = nn.ModuleList([layer_cls(embed_size, num_heads) for _ in range(num_layers)])
        self.ln_f = nn.LayerNorm(embed_size)  # 用于 GPT-2 的全局 LayerNorm
        self.fc = nn.Linear(embed_size, vocab_size)

    def forward(self, x):
        seq_len = x.size(1)
        pos = torch.arange(seq_len, device=x.device).unsqueeze(0)
        x = self.embed(x) + self.pos_embed(pos)
        for layer in self.layers:
            x = layer(x)
        x = self.ln_f(x)  # GPT-2 的全局 LayerNorm，GPT-1 可视情况移除
        return self.fc(x)


# Hyperparameters for GPT-1 and GPT-2
gpt1_config = {
    'vocab_size': 30522,
    'embed_size': 768,
    'num_heads': 12,
    'num_layers': 12,
    'max_len': 512,
    'layer_cls': GPT1Layer
}

gpt2_config = {
    'vocab_size': 50257,
    'embed_size': 1600,
    'num_heads': 25,
    'num_layers': 48,
    'max_len': 1024,
    'layer_cls': GPT2Layer
}

# Initialize models
gpt1 = GPT(**gpt1_config)
gpt2 = GPT(**gpt2_config)

# Loss function and optimizers
criterion = nn.CrossEntropyLoss()
optimizer1 = optim.Adam(gpt1.parameters(), lr=0.001)
optimizer2 = optim.Adam(gpt2.parameters(), lr=0.001)

# Example input (batch_size, seq_len)
batch_size1, batch_size2 = 2, 2
input_ids1 = torch.randint(0, gpt1_config['vocab_size'], (batch_size1, gpt1_config['max_len']))
input_ids2 = torch.randint(0, gpt2_config['vocab_size'], (batch_size2, gpt2_config['max_len']))

# Forward pass
outputs1 = gpt1(input_ids1)  # Output for GPT-1
outputs2 = gpt2(input_ids2)  # Output for GPT-2

print(f"GPT-1 Output Shape: {outputs1.shape}")  # (batch_size, seq_len, vocab_size)
print(f"GPT-2 Output Shape: {outputs2.shape}")  # (batch_size, seq_len, vocab_size)

def count_parameters(model):
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

def format_parameters(num_params):
    if num_params >= 1e9:
        return f"{num_params / 1e9:.2f}B"  # 转换为十亿单位并保留两位小数
    elif num_params >= 1e6:
        return f"{num_params / 1e6:.2f}M"  # 转换为百万单位并保留两位小数
    else:
        return f"{num_params}"

# 计算并格式化参数数量
gpt1_params = count_parameters(gpt1)
gpt2_params = count_parameters(gpt2)

print(f"GPT-1 Model Parameters: {format_parameters(gpt1_params)}")
print(f"GPT-2 Model Parameters: {format_parameters(gpt2_params)}")

在这里插入图片描述

参考

原文地址：https://blog.csdn.net/weixin_45956028/article/details/143953646

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Java爬虫的奇妙冒险：揭开1688商品详情的神秘面纱
下一篇：Flutter踩坑记录（三）-- 更改入口执行文件

CTF之密码学（RSA加密）
RSA加密算法由Ron Rivest、Adi Shamir和Leonard Adleman在1977年共同发明，并因此得名。它是第一个既能用于数据加密也能用于数字签名的算法。RSA的安全性基于数论中的
阅读更多2024-11-28
D81【 python 接口自动化学习】- python基础之HTTP
request请求可以使用session会话保持登录态...
阅读更多2024-11-28
理解B+树
在数据库的世界里，数据检索的速度至关重要。为了提高数据检索的效率，数据库系统采用了多种数据结构，其中B+树（B-plus Tree）因其独特的特性而成为索引实现的首选。今天，我们将深入探讨B+树的原理
阅读更多2024-11-28
输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。-多语言
输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。利用while语句,条件为输入的字符不为'\n'。
阅读更多2024-11-28
python控制鼠标，键盘，adb
更新中…
阅读更多2024-11-28
在 Linux 系统中根据pid查找软件位置
获取进程的命令名称。：获取进程的完整可执行文件路径。：使用lsof查找可执行文件路径。pwdx ：显示进程的工作目录。这些方法可以帮助您快速找到进程对应的可执行文件的位置。
阅读更多2024-11-28
VM+Ubuntu18.04+XSHELL+VSCode环境配置
为什么要用虚拟机？想学习Linux操作系统，一般有3种方法可以实现：将自己的操作系统换成Linux操作系统（Linux操作系统使用日常办公、游戏等不方便，不推荐）；安装双系统（Windows+Linu
阅读更多2024-11-28
【机器学习】机器学习基础
机器学习（Machine Learning, ML）是一种人工智能（AI）的分支，指计算机通过数据学习规律并做出预测或决策，而无需明确编程。它的核心目标是让机器能够从经验中学习，逐渐提高自身表现。
阅读更多2024-11-28
git源码安装
使用"wget"命令下载Git源码包，例如："wget https://www.kernel.org/pub/software/scm/git/git-2.0.5.tar
阅读更多2024-11-28
Modern Effective C++ item 15:尽可能的使用constexpr
当constexpr应用于函数时，表示函数可以在编译期执行，因为参数也是编译期常量。常量表达式构造函数拥有和常量表达式函数相同的退化特性，当它的实参不是常量表达式的时候，构造函数可以退化为普通构造函数
阅读更多2024-11-28