AI/ML 详解：LLM 基础

就像把"逐字读"的串行流水线换成了"全员同时开会"的并行架构 —— 每个 token 一次性看到全文，再决定自己要表达什么。

2017 年之前，处理文本主流是 RNN/LSTM，本质是个 for 循环：必须先算完第 t 个词，才能算第 t+1 个。这导致两个痛点：(1) 训练不能并行，慢；(2) 长距离依赖容易"遗忘"（梯度消失）。Transformer 用"自注意力"一次性建立任意两个位置的连接，于是 GPU 可以满负载并行，长依赖也不丢。

把每个 token 想象成一个对象，它有三个属性：Query（我想找什么）、Key（我能提供什么）、Value（我实际的内容）。每一层的逻辑大致是：

# 伪代码：一层 Transformer block
for token in sequence:
    # 1. 和全文每个 token 做 Q·K 相似度匹配（像数据库 JOIN）
    scores = token.Q @ all_tokens.K.T
    weights = softmax(scores)
    # 2. 按权重把别人的 Value 取过来做加权和
    token.new = weights @ all_tokens.V
    # 3. 再过一个前馈网络（相当于一个非线性映射）
    token.out = FFN(token.new + token)  # 残差连接

这样的 block 堆 12~96 层，每层都让 token 重新"问一遍全文"，表示就越来越丰富。

# 用 transformers 库加载一个 Transformer 模型，10 行看到全貌
from transformers import AutoTokenizer, AutoModel
import torch

tok = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModel.from_pretrained("bert-base-uncased")

inputs = tok("Transformers changed NLP.", return_tensors="pt")
with torch.no_grad():
    out = model(**inputs)

# out.last_hidden_state 形状：[batch, seq_len, hidden_dim]
# 每个 token 都被编码成一个 768 维向量，含了它在上下文中的"含义"
print(out.last_hidden_state.shape)  # torch.Size([1, 6, 768])

• Jay Alammar — The Illustrated Transformer（图解，最经典入门）
• Karpathy — Let's build GPT from scratch（2 小时跟着写）

经典：所有现代 LLM（GPT、Claude、Gemini、Llama）都是 Transformer。你的场景：当你用 Claude 写每日总结，它把你贴进去的 5000 字会议笔记一次性"扫"成一个语义向量，再生成摘要 —— 这是 Transformer 的并行注意力在帮你省时间。

就像 SQL 的 JOIN —— 每个词都拿着自己的"查询条件"去全文里匹配，找出最相关的词，然后把它们的内容加权拷过来一份。

"The cat sat on the mat because it was warm." 这里的 it 指 mat 还是 cat？传统模型只能按距离猜，而 Attention 让 it 这个位置主动去问全文："谁和我最相关？" 然后把 mat 的向量按高权重拿过来，自己的表示里就编码了"它指 mat"。本质：解决长距离指代和上下文聚焦。

核心公式 Attention(Q,K,V) = softmax(Q·Kᵀ / √d) · V。白话翻译："拿查询 Q 和所有 Key 做点积算相似度，归一化成权重，再去加权求和所有 Value。" 就是带权查表。

# 4 行 numpy 看懂 attention
import numpy as np
def attention(Q, K, V):
    scores = Q @ K.T / np.sqrt(K.shape[-1])  # 相似度
    weights = np.exp(scores) / np.exp(scores).sum(axis=-1, keepdims=True)
    return weights @ V                        # 加权求和

Multi-Head Attention = 同时开多个"独立查询通道"，每个 head 关注不同维度（句法/语义/指代…）的关系。

# 看看 GPT-2 实际在"关注"哪些词
from transformers import GPT2Tokenizer, GPT2Model
tok = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2Model.from_pretrained("gpt2", output_attentions=True)

inputs = tok("The cat sat on the mat", return_tensors="pt")
out = model(**inputs)
# out.attentions[layer][batch, head, query_pos, key_pos]
attn = out.attentions[-1][0, 0]   # 最后一层第 0 个 head
print(attn.shape)  # [6, 6]，每个词对其他词的注意力权重矩阵

• Illustrated Transformer — Attention 部分
• Distill — Attention and Augmented RNNs

经典：机器翻译时，目标语每个词都通过 attention 去"看"源语对应的词。你的场景：给孩子讲故事时，Claude 之所以能记住第一段提到的"小狐狸"在第三段还是同一只狐狸，靠的就是 attention 跨段建立指代连接。

就像编译器把源码切成 token —— LLM 处理文本前必须先把字符流切成"词块"，每个词块映射成一个整数 ID，模型其实只看 ID 不看字。

词表不能太大（每个词单独编号 → 几百万词表 → 矩阵爆炸），也不能太小（按字母切 → 序列太长，模型记不住语义）。解决方案：BPE / WordPiece / SentencePiece —— 按"高频字节组合"自动学习一个 5 万左右的子词表。常见词整词留下，生僻词拆成几片。

BPE 训练过程像"贪心压缩"：从单字符开始，反复把出现频率最高的相邻字符对合并成一个新 token，直到词表达到目标大小。

# BPE 直觉
# 初始: ['l','o','w','e','r']
# 发现 'l'+'o' 频次最高 → 合并 → ['lo','w','e','r']
# 再发现 'lo'+'w' 频次最高 → 合并 → ['low','e','r']
# 最终高频整词留下，低频词被拆成子词片段
# "tokenization" 可能被切成 ["token", "ization"]

结果：英文 1 token ≈ 4 字符 ≈ 0.75 词；中文 1 个汉字常占 2-3 个 token。这直接影响你的账单和上下文长度。

import tiktoken  # OpenAI 官方分词器

enc = tiktoken.get_encoding("cl100k_base")  # GPT-4 用的

text_en = "Tokenization is fun!"
text_zh = "分词其实很有意思！"

print(enc.encode(text_en))         # [3404, 2065, 374, 2523, 0]
print(len(enc.encode(text_en)))    # 5 tokens
print(len(enc.encode(text_zh)))    # 11 tokens（中文更贵！）

# 解码回去
print(enc.decode([3404, 2065]))   # "Tokeniz"  ← 不是完整词

• OpenAI Tokenizer 在线工具（贴文本看 token 切分）
• Karpathy — Let's build the GPT Tokenizer

经典：评估 API 成本（OpenAI 按 token 收费）。你的场景：同样一段会议笔记，用中文写比用英文写贵 2-3 倍。如果是高频自动化任务（如每天总结新闻），用英文 prompt + 中文输出能省钱。

Attention 本身是"无序集合"操作（像 Python 的 set），不知道谁在前谁在后。位置编码就像给每个 token 戳上一个"位置 ID"，让模型分得清"狗咬人"和"人咬狗"。

self-attention 计算 Q·Kᵀ 时，词的顺序完全没参与运算 —— 把句子打乱再算，结果不变。这显然不行。解决方案：在 token 的 embedding 里"注入"位置信息，让位置 0 和位置 5 有不同的初始向量。

三代演进：

• Sinusoidal（原版 Transformer）：用不同频率的 sin/cos 给每个位置生成一个独特向量，加到 token embedding 上。优点：能外推到训练时没见过的长度。
• Learned（GPT-2/BERT）：直接学一个 [max_len, dim] 的查表矩阵，简单但不能外推。
• RoPE 旋转位置编码（Llama/Qwen/现代主流）：把位置变成"旋转角度"，token 在高维空间里按位置转一定角度。两个 token 做 Q·K 点积时，自然就编码了"相对距离"。这是当下长上下文模型的标配。

# 直觉伪代码：RoPE 给位置 m 的向量旋转 m·θ 角度
def rope(x, pos):
    # x 是 token 的 Q 或 K 向量，按对划分
    for i, (a, b) in enumerate(pairs(x)):
        theta = pos / 10000 ** (2*i / dim)
        a_new = a * cos(theta) - b * sin(theta)
        b_new = a * sin(theta) + b * cos(theta)
    return rotated_x

# 观察位置编码对结果的影响
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tok = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

# 同样的 token，不同位置 → 不同的隐藏状态
ids_a = tok("dog bites man", return_tensors="pt").input_ids
ids_b = tok("man bites dog", return_tensors="pt").input_ids

with torch.no_grad():
    h_a = model.transformer(ids_a).last_hidden_state
    h_b = model.transformer(ids_b).last_hidden_state

# 即使是同样的 3 个 token，因为位置不同，最后表征完全不一样
print(torch.allclose(h_a, h_b))   # False

• HuggingFace — Designing Positional Encoding
• EleutherAI — Rotary Embeddings 详解

经典：所有需要顺序敏感的任务（翻译、代码生成、推理链）。你的场景：当你让 Claude 做"分析这 50 页 PDF 报告"，模型必须分得清第 3 页和第 47 页的内容 —— 这就靠位置编码（RoPE）在长上下文中保持位置感。