GPT：生成式预训练Transformer

一句话概述

GPT（Generative Pre-trained Transformer）是OpenAI开发的生成式预训练语言模型系列。与BERT的双向编码器不同，GPT使用Transformer的解码器部分（Decoder-only），通过自回归语言模型（Autoregressive LM）进行预训练——给定前文，预测下一个词。这种单向设计使GPT天然适合文本生成任务。GPT-1（2018）首次证明了大规模无监督预训练+有监督微调的有效性；GPT-2（2019）以15亿参数展示了零样本（zero-shot）能力；GPT-3（2020）以1750亿参数实现了少样本（few-shot）学习，不需要微调就能完成翻译、摘要、问答等任务；GPT-4（2023）引入多模态能力，在多个专业考试中达到人类顶尖水平。GPT系列的核心哲学是"规模即一切"——更大的模型、更多的数据、更长的训练，涌现出越来越强的能力。

💡 核心要点：①GPT使用Transformer解码器（Decoder-only），通过自回归语言模型预训练 ②GPT-1到GPT-4展示了模型规模扩大带来的能力涌现（emergent abilities）③GPT-3的1750亿参数实现了少样本学习，无需微调即可完成多种任务 ④GPT系列的核心是"预测下一个词"——看似简单的任务，大规模训练后涌现出惊人的智能

教学与演示

一、GPT的架构：自回归解码器

是什么（定义）：GPT使用Transformer的解码器部分（Decoder-only）。与完整Transformer解码器不同，GPT去掉了交叉注意力子层（因为没有编码器），只保留掩码自注意力和前馈网络。GPT通过自回归语言模型（Autoregressive LM）进行预训练——给定前文x_1, x_2, ..., x_{t-1}，预测下一个词x_t，最大化似然P(x_t | x_1, ..., x_{t-1})。这种"下一个词预测"的任务看似简单，但大规模训练后模型学会了语法、事实知识、推理能力等。

大白话 GPT就像一个"接龙高手"。你给它一个开头，它一个词一个词地往下接，每次接词时只能看到前面已经写过的内容（不能偷看后面的）。训练时，它读了互联网上几乎所有的文本，学会了"在这些词后面，下一个词大概率是什么"——这听起来简单，但当模型足够大、数据足够多时，它学到的不仅仅是词的搭配，而是整个世界知识、推理能力、甚至编程能力。就像一个读了整个图书馆的人，你让他续写一句话，他续写的质量取决于他读了多少书。

为什么（原理）：GPT选择自回归架构的原因是其生成能力。BERT的双向编码器虽然理解能力强，但不能生成文本（因为双向性违反因果性）。GPT的单向设计天然适合生成——从左到右逐词生成，每次生成的词都是基于前文的合理延续。这种设计还有一个优势：训练和推理完全一致（都是预测下一个词），不存在BERT中预训练（有[MASK]）和微调（无[MASK]）的不匹配问题。

import numpy as np

# GPT自回归语言模型的核心：预测下一个词
# 演示GPT如何通过"接龙"学习语言

class SimpleGPT:
    def __init__(self, vocab_size=100, d_model=8, max_len=10):
        np.random.seed(42)
        self.vocab_size = vocab_size
        self.d_model = d_model
        self.max_len = max_len

        # 词嵌入矩阵
        self.token_emb = np.random.randn(vocab_size, d_model) * 0.3
        # 位置嵌入（可学习）
        self.pos_emb = np.random.randn(max_len, d_model) * 0.1
        # 简化的Transformer解码器层
        self.W_attn = np.random.randn(d_model, d_model) * 0.2
        # 输出投影：将隐藏向量映射到词表
        self.W_out = np.random.randn(d_model, vocab_size) * 0.1

    def causal_attention(self, X):
        """因果（掩码）自注意力：每个位置只看前面"""
        n = X.shape[0]
        Q = K = X @ self.W_attn[:self.d_model, :self.d_model]
        scores = Q @ K.T / np.sqrt(self.d_model)
        # 因果掩码：屏蔽未来位置
        mask = np.triu(np.ones((n, n)) * -1e9, k=1)
        scores = scores + mask
        scores = scores - np.max(scores, axis=1, keepdims=True)
        attn = np.exp(scores) / np.sum(np.exp(scores), axis=1, keepdims=True)
        return attn @ X

    def forward(self, token_ids):
        """前向传播：预测每个位置的下一个词"""
        n = len(token_ids)
        # 词嵌入 + 位置嵌入
        X = self.token_emb[token_ids] + self.pos_emb[:n]
        # 因果自注意力
        hidden = self.causal_attention(X)
        # 预测下一个词的logits
        logits = hidden @ self.W_out
        # softmax得到概率分布
        logits = logits - np.max(logits, axis=1, keepdims=True)
        probs = np.exp(logits) / np.sum(np.exp(logits), axis=1, keepdims=True)
        return probs

    def generate(self, prompt_ids, steps=5):
        """自回归生成：逐词生成文本"""
        generated = list(prompt_ids)
        for _ in range(steps):
            probs = self.forward(generated)
            # 取最后一个位置的预测概率，采样下一个词
            next_token_probs = probs[-1]
            next_token = np.argmax(next_token_probs)  # 贪心解码
            generated.append(next_token)
        return generated


# 创建词汇映射（简化演示）
vocab = {0: "<s>", 1: "我", 2: "爱", 3: "人工", 4: "智能", 5: "学习",
         6: "深度", 7: "很", 8: "有趣", 9: "的", 10: "</s>"}

gpt = SimpleGPT(vocab_size=100, d_model=8, max_len=10)

# 演示自回归生成
prompt = [0, 1]  # "<s> 我"
print("=== GPT自回归生成演示 ===\n")
print(f"提示词: {' '.join(vocab.get(t, str(t)) for t in prompt)}")
print("生成过程（逐词生成）：")

generated = list(prompt)
for step in range(4):
    probs = gpt.forward(generated)
    next_token = np.argmax(probs[-1])
    generated.append(next_token)
    generated_text = " ".join(vocab.get(t, str(t)) for t in generated)
    print(f"  第{step+1}步: {generated_text}")

print(f"\n最终生成: {' '.join(vocab.get(t, str(t)) for t in generated)}")
print("\n关键特点：")
print("- 每次只生成一个词，基于前文（因果性）")
print("- 训练和推理使用相同的'预测下一个词'任务")
print("- 这就是GPT的核心：自动回归的语言建模")

大白话 GPT的训练目标就是"猜下一个词，猜对了加分，猜错了扣分"。给它看"我 爱 人工"，它猜"智能"——猜对了，得分高。给它看"我 爱 人工"，它猜"香蕉"——猜错了，得分低，需要调整参数。经过数万亿次的"猜词练习"，模型学会了词与词之间极其复杂的概率关系，从而能生成连贯、合理的文本。

什么用（应用）：GPT系列是当前最强大的文本生成模型。GPT-3可以完成翻译、摘要、问答、代码生成、创意写作等数十种任务，且不需要微调（只需在提示中给出几个示例）。GPT-4更进一步，在律师资格考试（Bar Exam）中得分超过90%的考生，在SAT数学中获得满分，在LeetCode编程挑战中击败多数人类程序员。ChatGPT（基于GPT-3.5/4）是历史上用户增长最快的应用，2个月达到1亿用户。

哪些坑（缺点）：GPT的核心局限包括：①幻觉（hallucination）——生成看似合理但事实错误的内容；②推理能力有限——虽然GPT-4在推理方面进步很大，但仍有逻辑错误；③计算成本高——GPT-3训练一次约需460万美元电费；④位置偏见——对开头和结尾的注意力分布不均；⑤无法实时更新知识——训练后的知识截止日期固定。

二、GPT系列演进：从1到4的规模之路

是什么（定义）：GPT系列经历了四个主要版本。GPT-1（2018）有1.17亿参数，使用BooksCorpus预训练，首次证明了"无监督预训练+有监督微调"的有效性。GPT-2（2019）有15亿参数，使用WebText（800万网页）训练，展示零样本能力。GPT-3（2020）有1750亿参数，使用45TB文本训练，实现少样本学习。GPT-4（2023）是多模态模型（支持图像输入），参数规模未公开（传言约1.8万亿），在多个专业考试中达到人类顶尖水平。

大白话 GPT系列就像"从小学到博士"的成长过程。GPT-1是"小学生"——1.17亿参数，会做基本的语言任务。GPT-2是"中学生"——15亿参数，展示了一些"天赋"（零样本能力）。GPT-3是"大学生"——1750亿参数，几乎什么都会，给几个例子就能学新任务。GPT-4是"博士"——参数规模未知，不仅能处理文字，还能看图理解，在律师考试、医学考试中超过多数人类。这个成长过程揭示了一个惊人的规律：模型越大，涌现的能力越强。

为什么（原理）：GPT系列的核心发现是"规模法则"（Scaling Laws）——随着模型参数、训练数据、计算量的增加，模型性能可预测地提升。更重要的是，某些能力（如推理、翻译、编程）在模型达到一定规模后"突然涌现"（emergent abilities）——小模型完全不会，大模型突然就会了。这类似于物理中的"相变"——量变积累到一定程度后引发质变。GPT-3的1750亿参数正是触发这些涌现能力的关键规模。

import numpy as np

# GPT系列的规模演进与应用能力演示
# 展示从GPT-1到GPT-4的参数量增长和能力涌现

class GPTEvolution:
    def __init__(self):
        self.gpt_versions = {
            "GPT-1 (2018)": {
                "params": "1.17亿",
                "layers": 12,
                "d_model": 768,
                "training_data": "BooksCorpus (~5GB)",
                "capabilities": ["文本分类微调", "文本蕴涵", "语义相似度"],
                "limitation": "需要微调才能完成下游任务"
            },
            "GPT-2 (2019)": {
                "params": "15亿",
                "layers": 48,
                "d_model": 1600,
                "training_data": "WebText (~40GB)",
                "capabilities": ["零样本学习", "文本生成", "简单翻译", "摘要"],
                "limitation": "零样本效果有限，不如微调模型"
            },
            "GPT-3 (2020)": {
                "params": "1750亿",
                "layers": 96,
                "d_model": 12288,
                "training_data": "Common Crawl等 (~45TB)",
                "capabilities": ["少样本学习", "代码生成", "数学推理", "多语言翻译"],
                "limitation": "推理成本高，偶尔产生幻觉"
            },
            "GPT-4 (2023)": {
                "params": "未公开（传言~1.8万亿）",
                "layers": "未公开",
                "d_model": "未公开",
                "training_data": "未公开（多模态数据）",
                "capabilities": ["多模态理解", "律师考试top10%", "医学诊断", "复杂推理"],
                "limitation": "实时性不足，知识截止日期固定"
            }
        }

    def demonstrate(self):
        print("=== GPT系列演进：从1到4的规模之路 ===\n")

        for version, info in self.gpt_versions.items():
            print(f"{'='*50}")
            print(f"  {version}")
            print(f"{'='*50}")
            print(f"  参数量: {info['params']}")
            print(f"  训练数据: {info['training_data']}")
            print(f"  核心能力: {', '.join(info['capabilities'])}")
            print(f"  主要局限: {info['limitation']}")
            print()

        # 规模法则演示
        print("\n=== 规模法则与能力涌现 ===\n")
        print("GPT-3论文中的关键发现：")
        print("  1. 模型性能随参数量的幂律提升")
        print("  2. 少样本能力在100亿参数左右开始涌现")
        print("  3. 1750亿参数时，少样本GPT-3在某些任务上超过微调的SOTA")
        print()
        print("能力涌现的例子：")
        print("  - 算术能力：<10亿参数几乎为0，>100亿参数突然提升")
        print("  - 翻译能力：<10亿参数很弱，>100亿参数接近专用翻译模型")
        print("  - 代码生成：<10亿参数不会，>100亿参数能写Python/JavaScript")
        print()
        print("这就是'规模即一切'(Scale is All You Need)的哲学！")


GPTEvolution().demonstrate()

大白话 规模法则就像一个"配方"——告诉你加多少"料"（参数和数据）能做出多好的"菜"（模型性能）。公式的意思是：参数翻倍，性能提升约5%；数据翻倍，性能提升约7%。虽然边际收益递减，但只要持续加大规模，性能就会持续提升。GPT-3就是按照这个配方，把参数量从GPT-2的15亿做到1750亿（约100倍），果然性能大幅提升。

什么用（应用）：GPT系列的应用已经遍布各个领域。ChatGPT是史上增长最快的消费应用；GitHub Copilot使用GPT技术辅助编程，被数百万开发者使用；Duolingo使用GPT-4进行语言教学；摩根士丹利使用GPT-4分析金融文档；Khan Academy使用GPT-4作为个性化导师。GPT系列还催生了提示工程（Prompt Engineering）、思维链（Chain-of-Thought）等新兴技术方向。

哪些坑（缺点）：GPT系列面临的主要挑战包括：训练成本天文数字（GPT-4训练估计数亿美元）；推理延迟（大模型生成速度慢）；幻觉问题（在需要事实准确性的场景中不可靠）；安全问题（可能被用于生成虚假信息、恶意代码）；环境影响（大模型训练和推理的碳排放）。这些问题正在推动模型压缩、知识蒸馏、对齐（Alignment）等研究方向。

三、GPT的提示工程与上下文学习

是什么（定义）：提示工程（Prompt Engineering）和上下文学习（In-Context Learning）是使用GPT系列模型的关键技术。提示工程指设计合适的输入文本（提示）来引导模型生成期望的输出。上下文学习指在提示中提供几个示例（few-shot），模型就能"学会"执行新任务——不需要任何参数更新。这是GPT-3最重要的能力之一：模型从提示中的示例"推断"任务模式，然后应用于新输入。

大白话 提示工程就像"给GPT写指令"。你想让GPT翻译英文到中文，你不能只说"翻译"，而要说"将以下英文翻译成中文：{英文}。中文翻译：{中文}"。好的提示就像好的"咒语"——说得越清楚，GPT做得越好。上下文学习就像"给GPT看例题"。你想让GPT做情感分析，就在提示里给2-3个例子："好评：这个产品太棒了！→ 正面。差评：质量太差了，后悔买了。→ 负面。"然后给它新的评论，它就能模仿你的格式给出判断。GPT不需要重新训练，看看例题就会了。

为什么（原理）：上下文学习的原理是：GPT在预训练时见过大量"示例+任务"的模式（如网页上的QA对、教程中的示例），学会了从上下文中推断模式。在推理时，Transformer的注意力机制让模型能够"看到"提示中的所有示例，并将示例中的模式（输入→输出映射）应用到新输入上。这本质上是一种"元学习"（meta-learning）——模型学会了"如何从示例中学习"。

import numpy as np

# 提示工程与上下文学习：GPT-3的核心能力
# 演示few-shot学习的工作原理

class PromptEngineering:
    def __init__(self):
        pass

    def demonstrate_few_shot(self):
        """演示不同提示策略的效果"""
        print("=== 提示工程与上下文学习 ===\n")

        # 任务：情感分析
        test_review = "这个产品质量一般，但价格还算合理"

        # 策略1：零样本（Zero-shot）——没有示例
        print("【零样本 (Zero-shot)】")
        zero_shot_prompt = (
            "判断以下评论的情感是正面还是负面。\n"
            f"评论：{test_review}\n"
            "情感："
        )
        print(f"提示：\n{zero_shot_prompt}")
        print("→ 模型需要从零推断任务，可能不准确\n")

        # 策略2：少样本（Few-shot）——给2个示例
        print("【少样本 (Few-shot)】")
        few_shot_prompt = (
            "判断以下评论的情感是正面还是负面。\n\n"
            "评论：产品质量很好，非常满意！\n"
            "情感：正面\n\n"
            "评论：太差了，完全不值这个价。\n"
            "情感：负面\n\n"
            f"评论：{test_review}\n"
            "情感："
        )
        print(f"提示：\n{few_shot_prompt}")
        print("→ 模型从示例中学习，输出更准确\n")

        # 策略3：思维链（Chain-of-Thought）——引导推理过程
        print("【思维链 (Chain-of-Thought)】")
        cot_prompt = (
            "逐步推理以下评论的情感。\n\n"
            "评论：产品质量很好，非常满意！\n"
            "推理：评论中包含'很好'、'满意'等正面词汇，表达了积极情绪。\n"
            "情感：正面\n\n"
            f"评论：{test_review}\n"
            "推理："
        )
        print(f"提示：\n{cot_prompt}")
        print("→ 引导模型展示推理过程，提高准确性\n")

        print("提示工程的核心技巧：")
        print("1. Zero-shot：直接问 → 适合简单任务")
        print("2. Few-shot：给2-5个示例 → 适合中等复杂度任务")
        print("3. Chain-of-Thought：引导推理 → 适合需要推理的复杂任务")
        print("4. 角色扮演：'你是一个专业的...' → 引导模型行为")
        print("5. 格式约束：指定输出格式 → 便于程序解析")


PromptEngineering().demonstrate_few_shot()

大白话 上下文学习就像"现场教学"。你是老师，GPT是学生。你不需要提前训练学生（预训练已经完成了），而是在考试前当着学生的面做2-3道例题（few-shot），然后让学生做新题。神奇的是，GPT真的能从这几个例题中"学会"做题方法——不是通过更新参数，而是通过注意力机制"参照"例题的模式。小模型（如GPT-2）做不到这一点，只有大模型（GPT-3）突然就会了——这就是"涌现"。

什么用（应用）：提示工程和上下文学习使得普通用户无需编程就能使用GPT模型。ChatGPT的对话界面本质上就是提示工程的交互式应用。在商业场景中，开发者通过精心设计的提示模板（Prompt Template）将GPT集成到应用中——如客服机器人（提示设置为"你是XX公司的客服，友好专业地回答用户问题"）、代码助手（提示设置为"你是一个Python专家，帮助用户调试代码"）、内容生成（提示设置为"你是一个专业的文案写手"）。

哪些坑（缺点）：提示工程的主要挑战是脆弱性——提示的微小变化（如换一个词、调整顺序）可能导致输出质量大幅变化。上下文长度有限——GPT-3的上下文窗口为2048个token，GPT-4扩展到128K，但长上下文推理质量会下降。此外，提示注入（Prompt Injection）攻击——用户通过在输入中插入恶意指令绕过模型的安全限制——是一个严重的安全问题。

概念关系图谱

重点答疑

Q1: GPT为什么选择Decoder-only架构而不是Encoder-Decoder？

Decoder-only架构有三个优势：①训练和推理一致——都是预测下一个词，没有BERT的预训练/微调不匹配问题；②天然适合生成——自回归生成是GPT的核心能力；③可以灵活处理任意任务——通过提示工程，将所有任务统一为"文本进→文本出"的格式。Encoder-Decoder虽然理论上表达能力更强，但实际使用中Decoder-only的简洁性和灵活性使其成为大模型的主流选择。

Q2: GPT-3的1750亿参数是如何分布的？

GPT-3的参数主要分布在：词嵌入矩阵（约6亿）、位置嵌入（约250万）、每层的自注意力权重（Q/K/V/O四个矩阵，每个d_model×d_model=12288×12288≈1.5亿，96层×4×1.5亿≈580亿）、每层的FFN权重（两个矩阵，d_model×d_ff和d_ff×d_model，其中d_ff=4×12288=49152，约12288×49152≈6亿，96层×2×6亿≈1150亿）。总参数约1750亿，其中FFN占大头（约66%），自注意力次之（约33%），嵌入层很小（约0.4%）。

Q3: 幻觉（Hallucination）为什么是大模型难以解决的问题？

幻觉的根源在于语言模型的目标函数——它优化的是"下一个词的概率"，而不是"事实准确性"。模型学会的是"什么样的文本看起来合理"，而不是"什么是真实的"。例如，模型知道"爱因斯坦出生于"后面通常跟着"1879年"，但如果你问"独角兽的学名是什么"，模型也会生成一个"看起来合理"的答案（因为训练数据中有类似格式的文本），而不是说"我不知道"。解决幻觉需要引入事实性约束（如检索增强生成RAG）或强化学习从人类反馈中学习（RLHF）。

章节单词汇总