LLM 基础概念面试题

答案：

Transformer 由 Encoder 与 Decoder 两个堆叠结构组成，核心是 Self-Attention 机制，通过 Query-Key-Value 三元组计算序列内部任意位置之间的依赖关系。

整体架构：

flowchart TB
    Input["输入 Token"] --> Embed["Input Embedding + Positional Encoding"]
    Embed --> Encoder
    subgraph Encoder["Encoder Stack（N 层）"]
        direction TB
        E1["Multi-Head Self-Attention"] --> E2["Add & LayerNorm（残差 + 归一化）"] --> E3["Feed-Forward Network（FFN）"] --> E4["Add & LayerNorm"]
    end
    Encoder --> Decoder
    Embed --> Decoder
    subgraph Decoder["Decoder Stack（N 层）"]
        direction TB
        D1["Masked Multi-Head Self-Attention（防止看到未来 token）"] --> D2["Add & LayerNorm"] --> D3["Cross-Attention（Encoder-Decoder Attention）"] --> D4["Add & LayerNorm"] --> D5["Feed-Forward Network"] --> D6["Add & LayerNorm"]
    end

Self-Attention 数学表达：

• Q（Query）：当前位置的查询向量
• K（Key）：所有位置的键向量，与 Q 计算相似度
• V（Value）：所有位置的值向量，根据注意力权重加权聚合
• $\sqrt{d_k}$：缩放因子，防止点积方差过大导致 softmax 进入饱和区

多头注意力（Multi-Head Attention）：

# PyTorch 风格伪代码
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, x, mask=None):
        B, T, _ = x.shape
        # 拆成 num_heads 个头
        Q = self.W_q(x).view(B, T, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(x).view(B, T, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(x).view(B, T, self.num_heads, self.d_k).transpose(1, 2)
        # 注意力分数
        scores = (Q @ K.transpose(-2, -1)) / math.sqrt(self.d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, float('-inf'))
        attn = F.softmax(scores, dim=-1)
        out = attn @ V
        return self.W_o(out.transpose(1, 2).contiguous().view(B, T, -1))

与 RNN/CNN 的对比：

答案：

Self-Attention 本身是置换等变的（permutation equivariant），对输入 token 顺序不敏感，必须显式注入位置信息。

Sinusoidal 位置编码（原始 Transformer）：

• 频率沿维度指数衰减，使不同维度对应不同波长
• 可天然外推到比训练更长的序列
• 与 Embedding 相加注入

主流实现方式：

RoPE 原理示意：

# RoPE 简化实现（按对维度旋转）
def rotate_half(x):
    x1, x2 = x[..., :x.shape[-1]//2], x[..., x.shape[-1]//2:]
    return torch.cat((-x2, x1), dim=-1)

def apply_rope(x, cos, sin):
    return x * cos + rotate_half(x) * sin

RoPE 将位置信息编码为复数域的旋转，Q 与 K 的内积自动携带相对位置差 $|i-j|$。

答案：

三者的根本差异在于 注意力掩码 与 预训练任务，决定了它们擅长理解（NLU）还是生成（NLG）。

架构对比：

Masked Attention 的区别：

# GPT / LLaMA：因果掩码（Causal Mask），位置 i 只能看到 <=i 的 token
mask = torch.triu(torch.ones(T, T), diagonal=1).bool()  # 上三角为 True
attn_scores = attn_scores.masked_fill(mask, float('-inf'))

# BERT：双向注意力，无 mask，所有位置互相可见
attn_scores = attn_scores  # 完整 n×n 注意力矩阵

适用场景：

• GPT / LLaMA：对话、写作、代码生成、Chain-of-Thought 推理
• BERT：文本分类、命名实体识别、问答（抽取式）、搜索召回
• LLaMA 系列：开源生态首选，是 vLLM、Ollama、llama.cpp 等推理引擎的事实标准底座

答案：

Tokenization 将原始文本切分为模型可识别的最小单元（token），直接影响词表大小、OOV 处理、多语言能力与推理效率。

主流子词算法：

BPE 训练流程：

# BPE 简化训练示意
from collections import Counter

def train_bpe(corpus, num_merges):
    # 1. 初始化：将每个词拆为字符序列 + 词尾标记 </w>
    vocab = Counter()
    for word in corpus:
        vocab[' '.join(list(word)) + ' </w>'] += 1
    # 2. 迭代 num_merges 次
    for _ in range(num_merges):
        # 统计所有相邻字符对频次
        pairs = Counter()
        for word, freq in vocab.items():
            symbols = word.split()
            for i in range(len(symbols) - 1):
                pairs[(symbols[i], symbols[i+1])] += freq
        # 合并频次最高的字符对
        best = pairs.most_common(1)[0][0]
        new_vocab = {}
        for word in vocab:
            new_word = word.replace(' '.join(best), ''.join(best))
            new_vocab[new_word] = vocab[word]
        vocab = new_vocab
    return vocab

关键差异点：

• BPE：基于频次贪心合并，实现简单，GPT 系标配
• WordPiece：基于语言模型似然（合并后似然提升最大），BERT 系标配
• SentencePiece：直接在原始文本上训练，将空格视为特殊 token（▁），避免语言相关预分词，对中日韩文友好

LLaMA Tokenizer 特征：

• 基于 SentencePiece + BPE
• 词表大小 32K（LLaMA 1）→ 128K（LLaMA 3，支持多语言）
• 数字按位切分，提升数字推理与算术能力
• 特殊 token：<s>（BOS）、</s>（EOS）、<unk>、<pad>

答案：

预训练在大规模无标注文本上学习通用语言知识，微调在下游任务标注数据上做有监督适配，两者构成现代 LLM 的两阶段范式。

两阶段对比：

全参数微调的痛点：

• 7B 模型全参数微调需 ~60GB 显存（FP32 梯度 + 优化器状态）
• 灾难性遗忘（Catastrophic Forgetting）：下游任务过拟合导致通用能力下降
• 多任务部署成本高：每个任务一份全量权重

LoRA（Low-Rank Adaptation）：

核心思想：冻结原始权重 $W_0 \in \mathbb{R}^{d \times k}$，仅训练低秩分解增量 $\Delta W = BA$，其中 $B \in \mathbb{R}^{d \times r}$，$A \in \mathbb{R}^{r \times k}$，秩 $r \ll \min(d, k)$。

# PEFT 库 LoRA 配置示例
from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=8,                          # 秩，越小越省显存
    lora_alpha=16,                # 缩放系数，通常 = 2*r
    target_modules=["q_proj", "v_proj"],  # 注入位置
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(base_model, config)
# 可训练参数量从 7B 降至 ~4M

QLoRA（Quantized LoRA）：

• 将基座模型量化到 4-bit（NF4），冻结存储
• 反向传播时反量化到 FP16/BF16 计算梯度
• 配合 Double Quantization 与 Paged Optimizer 进一步省显存
• 单张 24GB 消费级显卡即可微调 65B 模型

答案：

RLHF 通过人类偏好数据训练奖励模型，再用强化学习将 LLM 对齐到人类意图。后续演进出 DPO、PPO 等多种变体。

经典三阶段流程：

flowchart TD
    S1["Stage 1: 监督微调（SFT）
高质量指令-回答数据
Cross-Entropy Loss 训练 SFT 模型"]
    S2["Stage 2: 奖励模型训练（Reward Model）
同一 prompt 的多个回答
人类排序标注 → Pairwise Loss"]
    S3["Stage 3: 强化学习对齐（RL: PPO）
SFT 模型作为策略 π_θ
RM 评分作为奖励 r
目标: max E[r − β·KL(π_θ ‖ π_ref)]"]
    S1 --> S2 --> S3

PPO 目标函数：

• $r_\phi$：奖励模型打分
• $\beta$：KL 惩罚系数，防止策略漂移过远
• $\pi_{ref}$：参考策略（通常是 SFT 模型）

RLHF 算法演进：

DPO 损失函数：

其中 $y_w$ 为偏好回答（winner），$y_l$ 为非偏好回答（loser）。

答案：

提示工程通过设计输入文本的结构与示例，引导 LLM 产生期望输出，是不更新权重即可提升任务表现的核心手段。

主要范式：

CoT 提示示例：

# Zero-shot CoT
Q: 一个水池有两根管子，A 管 4 小时注满，B 管 6 小时注满，两管同时开多久注满？
A: 让我们一步步思考。

# Few-shot CoT
Q: 鸡兔同笼共 35 头 94 足，几只鸡几只兔？
A: 设有鸡 x 只，兔 y 只。x + y = 35，2x + 4y = 94。解得 y = 12, x = 23。答案是 23 只鸡 12 只兔。

Q: 一个水池有两根管子，A 管 4 小时注满，B 管 6 小时注满，两管同时开多久注满？
A: 

ReAct 框架：

# ReAct 伪代码
def react_agent(question, tools, max_steps=5):
    scratchpad = ""
    for step in range(max_steps):
        thought = llm(f"{scratchpad}\nQuestion: {question}\nThought:")
        if "Final Answer:" in thought:
            return extract_answer(thought)
        action = llm(f"{scratchpad}\nThought: {thought}\nAction:")
        observation = tools[action.tool].run(action.input)
        scratchpad += f"\nThought: {thought}\nAction: {action}\nObservation: {observation}"
    return "未找到答案"

最佳实践：

• 使用结构化分隔符：### Instruction ### / ### Context ### / ### Question ###
• 指定输出格式：JSON Schema、Markdown 表格
• 系统提示（System Prompt）放置全局规则，用户提示（User Prompt）放置具体任务
• 复杂任务拆解：让模型"先列出步骤，再逐步执行"

答案：

幻觉指模型生成貌似合理但与事实不符或无中生有的内容，是 LLM 部署的核心风险之一。

幻觉分类：

根因分析：

1. 训练数据噪声：互联网语料本身含错误信息
2. Next Token 目标函数：只优化局部似然，不保证全局事实正确
3. 知识截止：训练数据时效性限制
4. 解码策略：高 temperature、top-p 采样增加随机性
5. 长尾知识稀疏：低频实体训练样本不足
6. 过度自信：模型未学习"不知道"的能力

缓解策略：

RAG 缓解幻觉的机制：

• 提供可溯源上下文，模型有据可依
• 实时注入新知识，突破训练截止时间
• 支持引用标注，便于人工核查

答案：

上下文窗口指模型一次推理能处理的最大 token 数。LLM 的注意力复杂度为 $O(n^2)$，窗口扩大带来显存与计算双重压力。

主流模型上下文长度演进：

长上下文的核心挑战：

1. 显存爆炸：$n$ 个 token 的 KV Cache 占用 $O(n \cdot d \cdot L)$，70B 模型 128K 上下文需 ~40GB KV Cache
2. 计算复杂度：$O(n^2)$ 自注意力在 128K 时已不可承受
3. 位置编码外推：训练时未见过的长度位置表现下降
4. “迷失在中间”（Lost in the Middle）：长上下文中段信息利用效率低
5. 预训练成本：长文本训练数据稀缺

主流长上下文方案：

graph TD
    A[长上下文方案] --> B[位置编码外推]
    A --> C[注意力优化]
    A --> D[KV Cache 压缩]

    B --> B1[RoPE Scaling]
    B --> B2[ALiBi]
    B --> B3[YaRN]
    B --> B4[NTK-aware]

    C --> C1[Sparse Attention]
    C --> C2[Sliding Window]
    C --> C3[FlashAttention]
    C --> C4[Linear Attention]

    D --> D1[PagedAttention]
    D --> D2[Multi-Query Attention]
    D --> D3[Grouped-Query Attention]
    D --> D4[KV Cache Quantization]

答案：

RAG 通过在生成前检索外部知识库的相关片段，注入 LLM 上下文，解决知识时效性、幻觉、私域知识整合问题。

完整 RAG 流水线：

graph LR
    A[用户 Query] --> B[Query 理解]
    B --> C[Query 改写/扩展]
    C --> D[Embedding 模型]
    D --> E[向量检索]
    F[BM25/全文检索] --> E
    E --> G[Top-K 文档]
    G --> H[Rerank 重排]
    H --> I[Prompt 拼接]
    I --> J[LLM 生成]
    J --> K[带引用回答]

    L[文档] --> M[Chunk 切分]
    M --> N[Embedding]
    N --> O[向量数据库]
    O --> E

核心组件：

Chunking 策略：

# 常见切分方式
strategies = {
    "fixed_size":   "按固定 token 数切分，块大小 256-512",
    "recursive":    "按 [\\n\\n, \\n, 。, 空格] 递归切分，LangChain 默认",
    "semantic":     "按 embedding 相似度聚类切分",
    "markdown":     "按 Markdown 标题层级切分",
    "parent_child": "检索小块，注入大块上下文"
}

RAG 进阶技术：

• Hybrid Search：向量检索 + BM25 关键词检索融合，兼顾语义与字面
• Query Rewriting：用 LLM 改写用户 query，提升召回
• HyDE（Hypothetical Document Embeddings）：先用 LLM 生成假设性答案，再检索相似文档
• Self-RAG：模型自主决定是否检索，并自评检索质量
• GraphRAG：构建知识图谱，捕获实体关系
• Agentic RAG：多 Agent 协同检索，支持多轮、工具调用、条件分支

评估指标：

答案：

量化将模型权重与激活从 FP16/BF16 降精度到 INT8/INT4/FP8，减少显存占用、加速推理，但需控制精度损失。

核心概念：

• 对称量化：$x_q = \text{round}(x / s)$，$s = \max(|x|) / (2^{b-1}-1)$
• 非对称量化：$x_q = \text{round}((x - z) / s)$，多零点偏移
• Per-tensor / Per-channel / Per-group：缩放因子粒度，越细越准
• PTQ（Post-Training Quantization）：训练后量化，无需重训
• QAT（Quantization-Aware Training）：训练中模拟量化，精度更高

主流方法对比：

GPTQ 原理：

# GPTQ 核心思想：逐层量化，最小化重构误差
# 对每层权重 W，目标是找到量化后 Ŵ 使得 ||W X - Ŵ X||² 最小
# 利用 Hessian H = 2 X X^T 做二阶信息，计算量化顺序

# 使用示例
from auto_gptq import AutoGPTQForCausalLM
model = AutoGPTQForCausalLM.from_quantized(
    "TheBloke/Llama-2-7B-Chat-GPTQ",
    quantize_config={"bits": 4, "group_size": 128}
)

AWQ 原理：

• 观察：约 1% 的显著权重（salient weights）决定了大部分激活值
• 不量化这些显著权重（保留 FP16），其余权重量化到 INT4
• 激活感知：依据激活分布自动寻找最优 per-channel 缩放因子
• 优势：相比 GPTQ 推理速度更快，相同精度下 group_size 更小

量化选型建议：

答案：

LLM 推理是显存带宽与计算双重密集型任务，KV Cache 优化是吞吐提升的核心。

KV Cache 基础：

自回归推理时，每个新 token 需与历史所有 token 计算注意力。为避免重复计算历史 token 的 K、V 矩阵，将其缓存到显存：

# 推理时维护 KV Cache
class KVCache:
    def __init__(self, batch_size, num_heads, seq_len, head_dim):
        self.k = torch.zeros(batch_size, num_heads, seq_len, head_dim)
        self.v = torch.zeros(batch_size, num_heads, seq_len, head_dim)
        self.pos = 0

    def update(self, k_new, v_new):
        # 增量写入新 token 的 K、V
        self.k[:, :, self.pos] = k_new
        self.v[:, :, self.pos] = v_new
        self.pos += 1
        return self.k[:, :, :self.pos], self.v[:, :, :self.pos]

显存占用估算：

• 7B 模型（32 层，32 头，128 维）：单 token KV Cache ≈ $2 \times 32 \times 32 \times 128 \times 2 \text{ bytes} = 0.5 \text{ MB}$
• 128K 上下文：$0.5 \text{ MB} \times 128000 = 64 \text{ GB}$（单序列单 batch）
• 并发 32 路：直接爆显存

传统 KV Cache 的问题：

• 预分配最大长度，内部碎片 25%-50%
• 不支持请求间共享（如 system prompt 重复）
• 显存利用率低，限制并发

PagedAttention 核心思想：

借鉴操作系统虚拟内存的页表机制，将 KV Cache 划分为固定大小的 Block（如 16 token / block），通过 Block Table 做逻辑到物理的映射。

graph TB
    subgraph 请求1
        A1[Seq 1: 48 tokens] --> BT1[Block Table: 0,2,5]
    end
    subgraph 请求2
        A2[Seq 2: 32 tokens] --> BT2[Block Table: 1,3]
    end
    subgraph 物理Block池
        B0[Block 0: tokens 0-15]
        B1[Block 1: tokens 0-15]
        B2[Block 2: tokens 16-31]
        B3[Block 3: tokens 16-31]
        B4[Block 4: Free]
        B5[Block 5: tokens 32-47]
    end
    BT1 -.-> B0
    BT1 -.-> B2
    BT1 -.-> B5
    BT2 -.-> B1
    BT2 -.-> B3

关键技术收益：

配套优化技术：

• Continuous Batching：请求完成即刻释放 slot，新请求即时插入，GPU 利用率最大化
• Chunked Prefill：长 prompt 切分为多 chunk，与 decode 请求混合调度
• Prefix Cache：自动识别相同前缀，共享 KV Block
• Speculative Decoding：用小模型 draft token，大模型 verify，加速 2-3x
• FlashAttention：IO-aware 分块注意力，HBM 读写次数从 $O(n^2)$ 降至 $O(n)$
• KV Cache 量化：FP8 / INT8 缓存，显存再降 2-4x
• MQA / GQA：减少 KV 头数，KV Cache 体积降 4-8x

推理引擎对比：