GPT 图解 大模型是怎样构建的 - 黄佳

本书主要内容包括 N-Gram，词袋模型，Word2Vec，神经概率语言模型，循环神经网络，Seq2Seq，注意力机制，Transformer，从初代 GPT 到 ChatGPT 再到 GPT-4 等一系列突破性技术的诞生与演进。

关于作者

黄佳 是人工智能领域的技术作家和教育者：

• AI 技术专家：专注于自然语言处理和深度学习领域
• 技术作家：著有多本 AI 和机器学习相关书籍
• 教育者：擅长用通俗易懂的方式讲解复杂的 AI 概念

黄佳以其"图解"系列的写作风格著称，通过大量直观的图表和代码示例，帮助读者理解抽象的深度学习概念。

核心内容

1. N-Gram 语言模型

# N-Gram 基本原理
# 基于统计的语言模型，假设一个词只与前 N-1 个词相关

from collections import defaultdict

class NGramModel:
    def __init__(self, n=2):
        self.n = n
        self.ngrams = defaultdict(lambda: defaultdict(int))
        self.context_counts = defaultdict(int)

    def train(self, corpus):
        for sentence in corpus:
            tokens = sentence.lower().split()
            # 添加句子开始和结束标记
            tokens = ['<s>'] * (self.n - 1) + tokens + ['</s>']

            for i in range(len(tokens) - self.n + 1):
                context = tuple(tokens[i:i + self.n - 1])
                word = tokens[i + self.n - 1]
                self.ngrams[context][word] += 1
                self.context_counts[context] += 1

    def probability(self, context, word):
        return self.ngrams[context][word] / self.context_counts[context]

# 使用示例
corpus = [
    "I love machine learning",
    "I love deep learning",
    "Machine learning is powerful"
]

model = NGramModel(n=2)
model.train(corpus)
print(model.probability(('love',), 'machine'))  # P(machine | love)

2. Word2Vec 词向量

# Word2Vec 两种模型：
# 1. CBOW (Continuous Bag of Words): 用上下文预测中心词
# 2. Skip-gram: 用中心词预测上下文

# Skip-gram 实现示例
import numpy as np
from tensorflow import keras

class Word2Vec:
    def __init__(self, vocab_size, embedding_dim):
        self.vocab_size = vocab_size
        self.embedding_dim = embedding_dim

        # 输入向量到词向量 (W)
        self.W = keras.Sequential([
            keras.layers.Embedding(
                input_dim=vocab_size,
                output_dim=embedding_dim,
                input_length=1
            )
        ])

        # 词向量到输出向量 (W')
        self.U = keras.Sequential([
            keras.layers.Dense(
                units=vocab_size,
                activation='softmax'
            )
        ])

    def skip_gram(self, center_word, context_words):
        # center_word: 中心词索引
        # context_words: 上下文词索引列表
        pass

# 词向量特性
# king - man + woman ≈ queen
# vector('Paris') - vector('France') + vector('China') ≈ vector('Beijing')

3. 循环神经网络 (RNN)

import tensorflow as tf
from tensorflow import keras

# 标准 RNN
# 问题：梯度消失/梯度爆炸，难以学习长距离依赖

rnn_model = keras.Sequential([
    keras.layers.Embedding(input_dim=10000, output_dim=128),
    keras.layers.SimpleRNN(64, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

# LSTM (Long Short-Term Memory)
# 引入门控机制：遗忘门、输入门、输出门

lstm_model = keras.Sequential([
    keras.layers.Embedding(input_dim=10000, output_dim=128),
    keras.layers.LSTM(64, return_sequences=True),
    keras.layers.LSTM(32),
    keras.layers.Dense(10, activation='softmax')
])

# GRU (Gated Recurrent Unit)
# LSTM 的简化版本

gru_model = keras.Sequential([
    keras.layers.Embedding(input_dim=10000, output_dim=128),
    keras.layers.GRU(64, return_sequences=True),
    keras.layers.GRU(32),
    keras.layers.Dense(10, activation='softmax')
])

4. Seq2Seq 模型

# Encoder-Decoder 架构
# 应用：机器翻译、文本摘要、对话系统

from tensorflow.keras import layers, Model

# Encoder
encoder_inputs = layers.Input(shape=(None,))
encoder_embedding = layers.Embedding(10000, 256)(encoder_inputs)
encoder_lstm = layers.LSTM(512, return_state=True, return_sequences=True)
encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
encoder_states = [state_h, state_c]

# Decoder
decoder_inputs = layers.Input(shape=(None,))
decoder_embedding = layers.Embedding(10000, 256)(decoder_inputs)
decoder_lstm = layers.LSTM(512, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=encoder_states)
decoder_dense = layers.Dense(10000, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

# 注意力机制的引入解决了瓶颈问题

5. 注意力机制 (Attention)

# Scaled Dot-Product Attention
import tensorflow as tf
import numpy as np

def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    Q: Query 矩阵 (batch_size, seq_len_q, d_k)
    K: Key 矩阵 (batch_size, seq_len_k, d_k)
    V: Value 矩阵 (batch_size, seq_len_v, d_v)
    """
    d_k = tf.cast(tf.shape(K)[-1], tf.float32)

    # 计算注意力分数
    attention_scores = tf.matmul(Q, K, transpose_b=True)
    attention_scores = attention_scores / tf.math.sqrt(d_k)

    # 应用掩码（可选）
    if mask is not None:
        attention_scores += (mask * -1e9)

    # Softmax 归一化
    attention_weights = tf.nn.softmax(attention_scores, axis=-1)

    # 加权求和
    output = tf.matmul(attention_weights, V)

    return output, attention_weights

# 注意力机制的优势：
# 1. 并行计算，训练效率高
# 2. 捕获长距离依赖
# 3. 可解释性强（可可视化注意力权重）

6. Transformer 架构

# Transformer = Multi-Head Attention + Feed Forward + Layer Norm

class MultiHeadAttention(layers.Layer):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.d_model = d_model

        assert d_model % num_heads == 0

        self.depth = d_model // self.num_heads

        self.wq = layers.Dense(d_model)
        self.wk = layers.Dense(d_model)
        self.wv = layers.Dense(d_model)

        self.dense = layers.Dense(d_model)

    def split_heads(self, x, batch_size):
        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))
        return tf.transpose(x, perm=[0, 2, 1, 3])

    def call(self, Q, K, V, mask=None):
        batch_size = tf.shape(Q)[0]

        q = self.wq(Q)
        k = self.wk(K)
        v = self.wv(V)

        q = self.split_heads(q, batch_size)
        k = self.split_heads(k, batch_size)
        v = self.split_heads(v, batch_size)

        scaled_attention, _ = scaled_dot_product_attention(q, k, v, mask)

        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])
        concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model))

        output = self.dense(concat_attention)
        return output

# Transformer Encoder 层
class EncoderLayer(layers.Layer):
    def __init__(self, d_model, num_heads, dff, dropout_rate=0.1):
        super().__init__()
        self.mha = MultiHeadAttention(d_model, num_heads)
        self.ffn = keras.Sequential([
            layers.Dense(dff, activation='relu'),
            layers.Dense(d_model)
        ])
        self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)
        self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)
        self.dropout = layers.Dropout(dropout_rate)

    def call(self, x, training=False, mask=None):
        attn_output = self.mha(x, x, x, mask)
        attn_output = self.dropout(attn_output, training=training)
        out1 = self.layernorm1(x + attn_output)

        ffn_output = self.ffn(out1)
        ffn_output = self.dropout(ffn_output, training=training)
        out2 = self.layernorm2(out1 + ffn_output)

        return out2

7. GPT 系列演进

GPT 发展路线图：

1. GPT (2018)
   - 参数：1.17 亿
   - 训练数据：BookCorpus (7000 本书)
   - 创新：Decoder-only Transformer, 无监督预训练 + 有监督微调

2. GPT-2 (2019)
   - 参数：15 亿
   - 训练数据：40GB 网络文本
   - 创新：多任务学习，zero-shot 能力

3. GPT-3 (2020)
   - 参数：1750 亿
   - 训练数据：Common Crawl, WebText, Books, Wikipedia
   - 创新：In-context Learning (Few-shot Prompting)

4. ChatGPT (2022)
   - 基于 GPT-3.5
   - 创新：RLHF (Reinforcement Learning from Human Feedback)
   - 特点：对话优化，遵循指令能力强

5. GPT-4 (2023)
   - 多模态模型 (文本 + 图像)
   - 更强的推理和代码能力
   - 更大的上下文窗口

8. RLHF (人类反馈强化学习)

# RLHF 三阶段流程

# 1. 监督微调 (SFT)
# 使用人工标注的高质量对话数据微调预训练模型
sft_model = pretrain_model.finetune(
    dataset=sft_dataset,  # 人工标注的对话数据
    learning_rate=1e-5,
    epochs=3
)

# 2. 奖励模型训练 (Reward Model)
# 训练一个模型来判断回复的质量
# 输入：(prompt, response) 对
# 输出：质量评分

class RewardModel(nn.Module):
    def __init__(self, base_model):
        super().__init__()
        self.base_model = base_model
        self.reward_head = nn.Linear(hidden_size, 1)

    def forward(self, input_ids, attention_mask):
        hidden = self.base_model(input_ids, attention_mask)
        # 使用最后一个 token 的隐藏状态
        reward = self.reward_head(hidden[:, -1, :])
        return reward

# 3. 强化学习优化 (PPO)
# 使用奖励模型指导策略优化
# 目标：最大化奖励 + 保持与 SFT 模型的距离 (KL 散度惩罚)

# 损失函数
loss = -log_prob * (reward - baseline) + beta * KL(sft_model, current_model)

经典摘录

语言模型的本质是学习语言的概率分布。好的语言模型能够捕捉语言的规律和模式。

从 RNN 到 Transformer，是序列建模从串行进到并行的革命。

注意力机制让模型能够关注输入中最重要的部分，就像人类的注意力一样。

GPT 系列的成功证明了一个简单的道理：大规模预训练 + 微调，是通向通用人工智能的有效路径。

RLHF 让人类价值观能够"注入"到大模型中，这是 AI 对齐的关键一步。

读书心得

《GPT 图解》是一本非常适合入门大模型技术的书籍。作者从最基础的 N-Gram 开始，循序渐进地讲解到最新的 GPT-4，让读者能够理解大模型技术的发展脉络。

书中对我帮助最大的是从历史演进角度理解技术。很多看似高深的概念，其实都有清晰的发展线索：

• N-Gram → 语言模型的雏形
• Word2Vec → 分布式表示的突破
• RNN → 序列建模的尝试
• LSTM → 长距离依赖的解决
• Attention → 并行计算的革命
• Transformer → 现代大模型的基石

Transformer 架构的讲解非常清晰。通过多头注意力、位置编码、层归一化等组件的拆解，让复杂的架构变得容易理解。这对于后续理解 GPT、BERT 等模型非常有帮助。

RLHF部分的讲解也让我印象深刻。这是让大模型从"能回答问题"到"能友好对话"的关键技术。理解 RLHF 的原理，对于把握当前大模型的发展方向非常重要。

虽然书中部分技术细节可能需要反复阅读才能完全理解，但整体的"图解"风格确实降低了学习门槛。对于想要进入 AI 领域的开发者来说，这是一本很好的入门书籍。