第 6 章：Transformer 架构解读 —— LLM 引擎如何运转¶

import numpy as np

# 假设词汇表有 50000 个 token，每个用 768 维向量表示
vocab_size = 50000
embed_dim = 768

# 嵌入矩阵：每一行是一个 token 的向量表示
embedding_matrix = np.random.randn(vocab_size, embed_dim) * 0.02

# 输入: "今天天气真好" → token IDs
token_ids = np.array([1234, 5678, 9012, 3456, 7890])

# 查表获取嵌入向量
token_embeddings = embedding_matrix[token_ids]
print(f"输入 token 数: {len(token_ids)}")
print(f"嵌入向量形状: {token_embeddings.shape}")  # (5, 768)
print(f"第一个 token 的嵌入向量 (前5维): {token_embeddings[0, :5]}")

def sinusoidal_position_encoding(seq_len, embed_dim):
    """
    原始 Transformer 使用正弦/余弦函数生成位置编码
    每个维度的频率不同，形成独特的位置"指纹"
    """
    position = np.arange(seq_len)[:, np.newaxis]  # (seq_len, 1)
    div_term = np.exp(np.arange(0, embed_dim, 2) * 
                      (-np.log(10000.0) / embed_dim))  # (embed_dim/2,)

    pe = np.zeros((seq_len, embed_dim))
    pe[:, 0::2] = np.sin(position * div_term)   # 偶数维用 sin
    pe[:, 1::2] = np.cos(position * div_term)   # 奇数维用 cos

    return pe

# 可视化位置编码
import matplotlib.pyplot as plt

seq_len, embed_dim = 50, 128
pe = sinusoidal_position_encoding(seq_len, embed_dim)

plt.figure(figsize=(10, 4))
plt.imshow(pe, aspect='auto', cmap='RdBu')
plt.colorbar(label='编码值')
plt.xlabel('嵌入维度')
plt.ylabel('位置')
plt.title('正弦位置编码：每个位置有独特的"指纹"')
plt.show()

# 最终输入 = 词嵌入 + 位置编码
final_input = token_embeddings + pe[:len(token_ids)]
print(f"最终输入形状: {final_input.shape}")  # (5, 768)

def feed_forward_network(x, W1, b1, W2, b2):
    """
    x: 输入向量，形状 (seq_len, embed_dim)
    W1: 第一层权重 (embed_dim, ffn_dim)，ffn_dim 通常是 embed_dim 的 4 倍
    W2: 第二层权重 (ffn_dim, embed_dim)
    """
    # 第一层：升维
    hidden = np.maximum(0, np.dot(x, W1) + b1)  # ReLU

    # 第二层：降维回原始维度
    output = np.dot(hidden, W2) + b2

    return output

# 示例
embed_dim, ffn_dim = 768, 3072  # ffn_dim = 4 * embed_dim
W1 = np.random.randn(embed_dim, ffn_dim) * 0.02
b1 = np.zeros(ffn_dim)
W2 = np.random.randn(ffn_dim, embed_dim) * 0.02
b2 = np.zeros(embed_dim)

x = np.random.randn(5, embed_dim)  # 5 个 token
output = feed_forward_network(x, W1, b1, W2, b2)
print(f"FFN 输入形状: {x.shape}")
print(f"FFN 输出形状: {output.shape}")  # 形状不变

def residual_connection(x, sublayer_fn):
    """残差连接：输入 + 子层输出"""
    return x + sublayer_fn(x)

def layer_norm(x, epsilon=1e-5):
    """
    对每个样本的所有特征做归一化
    x: (seq_len, embed_dim)
    """
    mean = np.mean(x, axis=-1, keepdims=True)
    std = np.std(x, axis=-1, keepdims=True)
    return (x - mean) / (std + epsilon)

def create_causal_mask(seq_len):
    """
    创建因果掩码矩阵
    1 表示可以看到，0 表示需要屏蔽
    """
    mask = np.tril(np.ones((seq_len, seq_len)))  # 下三角矩阵
    return mask

# 可视化
seq_len = 5
mask = create_causal_mask(seq_len)

print("因果掩码矩阵（1=可见, 0=屏蔽）:")
print(mask)
print("\n解读: 第 i 行第 j 列 = 1 表示预测第 i 个词时可以看第 j 个词")
print("例如第 3 行: 预测第 3 个词时，可以看到第 0,1,2 个词，不能看第 3,4 个词")

class TransformerBlock:
    """一个 Transformer Decoder 层的完整实现"""

    def __init__(self, embed_dim=768, num_heads=12, ffn_dim=3072):
        self.embed_dim = embed_dim
        self.num_heads = num_heads

        # 自注意力参数（第7章详解）
        self.W_q = np.random.randn(embed_dim, embed_dim) * 0.02
        self.W_k = np.random.randn(embed_dim, embed_dim) * 0.02
        self.W_v = np.random.randn(embed_dim, embed_dim) * 0.02
        self.W_o = np.random.randn(embed_dim, embed_dim) * 0.02

        # 前馈网络参数
        self.W1 = np.random.randn(embed_dim, ffn_dim) * 0.02
        self.b1 = np.zeros(ffn_dim)
        self.W2 = np.random.randn(ffn_dim, embed_dim) * 0.02
        self.b2 = np.zeros(embed_dim)

    def self_attention(self, x, mask=None):
        """多头自注意力（简化版，第7章详解）"""
        Q = np.dot(x, self.W_q)
        K = np.dot(x, self.W_k)
        V = np.dot(x, self.W_v)

        # 注意力分数
        scores = np.dot(Q, K.T) / np.sqrt(self.embed_dim)

        # 应用因果掩码
        if mask is not None:
            scores = np.where(mask == 0, -1e9, scores)

        # Softmax + 加权求和
        attention_weights = np.exp(scores - np.max(scores, axis=-1, keepdims=True))
        attention_weights /= np.sum(attention_weights, axis=-1, keepdims=True)

        context = np.dot(attention_weights, V)
        return np.dot(context, self.W_o)

    def forward(self, x, mask=None):
        # 1. 自注意力 + 残差 + 层归一化
        attn_out = self.self_attention(x, mask)
        x = layer_norm(x + attn_out)

        # 2. 前馈网络 + 残差 + 层归一化
        ffn_out = feed_forward_network(x, self.W1, self.b1, self.W2, self.b2)
        x = layer_norm(x + ffn_out)

        return x

# 测试
seq_len, embed_dim = 5, 768
x = np.random.randn(seq_len, embed_dim)
mask = create_causal_mask(seq_len)

block = TransformerBlock()
output = block.forward(x, mask)
print(f"Transformer Block 输入形状: {x.shape}")
print(f"Transformer Block 输出形状: {output.shape}")
print(f"输入输出形状相同: {x.shape == output.shape}")