import torchimport torch.nn as nnimport torch.nn.functional as Fclass MultiHeadAttention(nn.Module): def __init__(self, hidden_size, num_heads): super().__init__() self.num_heads = num_heads self.head_dim = hidden_size // num_heads self.q_linear = nn.Linear(hidden_size, hidden_size) self.k_linear = nn.Linear(hidden_size, hidden_size) self.v_linear = nn.Linear(hidden_size, hidden_size) self.o_linear = nn.Linear(hidden_size, hidden_size) def forward(self, hidden_state, causal_mask=None, past_key_value=None, use_cache=False): batch_size = hidden_state.size(0) query = self.q_linear(hidden_state) key = self.k_linear(hidden_state) value = self.v_linear(hidden_state) # 多头拆分 query = query.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2) key = key.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2) value = value.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2) # 拼接 KV cache if past_key_value is not None: past_key, past_value = past_key_value key = torch.cat([past_key, key], dim=2) value = torch.cat([past_value, value], dim=2) new_past_key_value = (key, value) if use_cache else None # 注意力打分 attention_scores = torch.matmul(query, key.transpose(-1, -2)) \ / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32)) if causal_mask is not None: attention_scores += causal_mask * -1e9 attention_probs = F.softmax(attention_scores, dim=-1) output = torch.matmul(attention_probs, value) # 合并多头 output = output.transpose(1, 2).contiguous() \ .view(batch_size, -1, self.num_heads * self.head_dim) output = self.o_linear(output) return (output, new_past_key_value) if use_cache else output
Q6. Multi-Head Attention 和 Single-Head Attention 的区别？Multi-Head 有什么好处？
Multi-Head 把 hidden_size 拆成多个并行的子空间，每个 head 学习不同的关注模式（如语法、语义、位置等），再拼接回去。
好处：
多角度建模：每个头关注不同的子空间特征
表达能力更强：相比单头能捕获更丰富的依赖
并行性好：多头之间天然并行
Q7. Transformer 里的 Attention 和 Feed Forward 各自的作用？
Q8. 大模型怎么处理梯度消失和梯度爆炸？
残差连接（Residual Connection）：保证梯度可以直通传到浅层
LayerNorm/RMSNorm：稳定每层的激活值分布
更稳定的初始化：如 Xavier、Kaiming
梯度裁剪（Gradient Clipping）：防止梯度爆炸
学习率 warmup + decay：避免训练初期发散
混合精度训练+Loss scaling：解决FP16下梯度下溢出问题
Q9. 大模型输入文本后怎么得到输出？/ Transformer 推理流程
文本输入，tokenizer 将文本切分成更小的单元，根据预先准备的词表映射成唯一的token id
通过Embedding和位置编码，将token id转化为带有位置信息的向量序列
进入Prefill阶段，模型并行计算输入序列的上下文信息并构建KV Cache
Decode阶段，模型基于已生成的上文和缓存信息，预测下一个token的概率分布，选出概率最高的词后将其追加回输入序列，并更新缓存
如此反复迭代，直到生成结束符或达到长度限制
Q10. 第一个token是怎么来的？
第一个生成的 token 来自 Prefill 阶段：用户输入经过 tokenizer + embedding 后整段并行送入模型，最后一层输出对应”输入末尾位置”的 hidden state，经过 LM Head（线性层）→ logits → 采样策略（greedy / top-k / top-p）→ 得到第一个生成的 token。
Q11. 介绍一下PD分离（Prefill-Decode 分离）
Prefill 和 Decode 两个阶段的特性差异极大：
混合在一起会互相干扰：长prefill卡住短decode，导致延迟抖动。PD分离把两个阶段调度到不同的实例（甚至不同硬件），各自批处理，从而提升整体吞吐和SLA。
Q12. KV Cache 原理？
利用”空间换时间“的策略，解决自回归生成过程中的重复计算问题。
在 Transformer 生成文本时，每次生成新 token 都需要关注之前的所有 token；如果没有缓存，模型必须不断重复计算历史序列的 Key 和 Value 向量，导致计算复杂度呈平方级增长。
KV Cache 通过在显存中保存已计算过的历史 Key 和 Value 状态，使得模型在生成下一个token时，只需计算当前token的Query和新的Key/Value，并直接复用缓存中的历史数据。
这一机制将推理的计算复杂度从 O(n²) 降低到 O(n)，是大模型实现低延迟流式输出的关键。
Q13. KV Cache 还有哪些其他优化手段？
PagedAttention（vLLM）：把KV cache分块管理，避免显存碎片
Continuous Batching：动态拼batch MQA/GQA：多个Query head共享K/V，减少cache体积
量化 KV cache：把KV从FP16量化到INT8/INT4
KV cache压缩/驱逐：H2O、StreamingLLM 等丢掉不重要的 token
Prefix Caching：相同前缀的请求复用 KV
Q14. Flash Attention 原理（目标+方法）
Q15. Flash Attention 不同版本之间有什么区别？
FA1：分块 + online softmax
FA2：改变了循环的嵌套顺序，先处理Q（外层），KV（内层），结束后统一归一化；减少非矩阵乘法计算，更好利用Tensor Core；如果一个Block 处于矩阵上三角部分（causal mask），不进行attention计算
FA3：针对Hopper架构，利用TMA和WGMMA，让Softmax和GEMM重叠执行，用Tensor Core的计算时间掩盖SFU（exp）的低吞吐
FA4：针对Blackwell架构，高速online softmax（如果最大值在一定范围就不更新）；高效的exp，使用多项式拟合仿真指数操作，接近矩阵运算
Q16. 应用Flash Attention时，如果mask是随机/不规则的怎么处理？
Flash Attention的高效来自于“整块跳过”——causal mask下右上三角的 block完全不算。如果mask是随机的：
Block-sparse 化：按 block 粒度判断是否全 0，全 0 的 block 直接跳过；非全 0 的 block 内部按元素应用 mask
传 mask 索引：把”哪些 (Q-block, KV-block) 对需要计算”的列表传进 kernel（FlexAttention / FlashAttention 的 block-sparse 接口就是这种思路）
在 kernel 里把 mask 加到 scores 上（scores += mask * -inf），让 softmax 自动屏蔽
极不规则时，partial-block 的开销可能让收益打折，需要权衡
Q17. Flash Attention 比较复杂，哪部分比较困难？
主要难点：
online softmax 的数值稳定性（max 的累积更新）
分块大小的选择：要兼顾 SRAM 容量、寄存器压力、warp 调度
反向传播的重计算逻辑与前向对齐
多 batch / 多 head / 不同 head_dim 的边界处理
Q18. 了解过其他 Attention 类的加速手段（论文）吗？
Multi-Query Attention (MQA) / Grouped-Query Attention (GQA)：减少 KV head 数量
Sliding Window Attention（Mistral）
Linear Attention / Performer / Linformer：把复杂度降到 O(n)
PagedAttention（vLLM）
RingAttention：跨GPU切分长序列
FlexAttention：用编译器自动生成融合 kernel
Q19. 量化的原理？
量化是指将连续取值离散化成有限取值的过程。模型量化即将权重、激活值等从高精度转化成低精度的操作过程（如 FP32 → INT8）。
Q20. 量化的好处（目的）？
更小的模型尺寸：以 8bit 量化为例，与 32bit 浮点数相比，模型体积降低为原来的1⁄4
更低的功耗：移动 8bit 数据比移动 32bit 浮点型数据效率高 4 倍
更快的计算速度：大多数处理器都支持 8bit 数据的更快处理；二值量化更有优势
Q21. 量化的分类？
PTQ：直接转换训练好的模型
QAT：训练时模拟量化过程
混合精度量化：关键层保持高精度
Q22. 模型在运行时哪部分是动态量化、哪部分是静态量化？
Q23. 为什么有的只量化weight，有的activation和weight都量化？
只量化权重：
权重 + 激活都量化：
结论：只量化权重只减少模型大小，推理速度不会有明显提升；权重 + 激活量化能极大提升推理速度，但模型精度会有所下降。
Q24. 量化踩过的坑？
精度陷阱：做分组量化时直接用 max/min 校准，但某些分组中会有个别离群值，导致整个分组的范围被拉得很宽，最终效果较差。
解决思路：截尾（如 percentile 校准）、SmoothQuant、AWQ、对离群通道单独处理。
Q25. 模型蒸馏、模型剪枝、量化的区别？
最重要的区别是：蒸馏改的是训练范式（让小模型学大模型），剪枝改的是网络拓扑（去掉不重要的连接），量化只改数值表示。
Q26. 如何对训练后的模型做量化？（Flow Matching 改了网络结构，原训练精度 BF16）
优先选择 PTQ（Post-Training Quantization）：
采集一批校准数据
用模型跑前向，统计每一层的 activation 分布
对 weight 和 activation 做量化映射：BF16 → INT8
如果 PTQ 掉点严重，用 QAT（Quantization-Aware Training）：
可能遇到的问题：激活值离群点、不同分支量化范围不一致、扩散步数累积误差。
Q27. 如果 INT8 掉点严重怎么办？
切换到 QAT
使用混合精度：敏感层（如最后输出层、首层）保留 BF16
使用更细粒度的 per-channel / per-group 量化
离群点处理：SmoothQuant（把激活的离群值迁移到权重）、AWQ
检查校准集是否覆盖真实分布
Q28. 为什么用 INT4？
更高压缩比：相比 INT8 再缩 1/2，4B 模型可在端侧 4GB 显存运行
带宽更友好：Decode 阶段是 Memory-Bound，权重读取量减半直接提速
精度可控：通过分组量化（K-Quant、AWQ、GPTQ）能把精度损失压到很小
劣势：纯整数 INT4 GEMM 硬件支持有限（目前主流是 W4A16，权重 INT4 但激活 FP16），所以加速主要来自带宽减少而非算力翻倍。
Q29. INT4 量化怎么降低时延和显存？
Q30. 了解过 FP8 量化吗？
FP8 有 E4M3 和 E5M2 两种格式：
H100 / Blackwell 原生支持 FP8 Tensor Core。相比 INT8，FP8 的浮点性质让它对激活的离群值更友好，几乎不需要复杂的校准。
Q31. 量化后的权重怎么参与计算？
以 llama.cpp Q4_K_M 为例：
从块中解包 4-bit 权重，用 scale + min 反量化回 FP16，得到 FP16 权重矩阵，和 FP16 激活做矩阵乘法（当场解包，当场丢弃）。
w_fp16 = q4 * (scale * d) - (minv * dmin)
其中：
d：全局 scale（FP16，整个 256 维超块共用）
dmin：全局 min（FP16，整个 256 维超块共用）
scale：子块局部 scale（6-bit，32 维子块用）
minv：子块局部 min（6-bit，32 维子块用）
Q32. 如何评估量化损失是可以接受的？精度损失大时如何定位？
评估指标：
Q33. MatMul 怎么优化的？计算瓶颈在哪里？
瓶颈：访存（从 GMEM 读取矩阵）和算力。
常见优化手段：
分块 (Tiling)：按 M、N、K 分块加载到 SMEM
寄存器分块 (Warp Tiling)：每个线程持有更大的输出 tile
double buffering：计算和访存 overlap
Tensor Core 利用：用 wmma / mma 指令
避免 bank conflict：合理 padding SMEM 布局
vectorized load：float4 一次加载 16 字节
Q34. 矩阵乘有根据 N、M、K 分块吗？
是。三个维度都要分：
典型的 BLOCK 大小：BM=128, BN=128, BK=8/16/32（依架构而定）。
Q35. Bank Conflict 是什么？
同一个 warp 里的不同线程从同一个 bank 里取数据就会造成 bank conflict，内存读取效率偏低（被串行化）。
GPU SMEM 通常分为 32 个 bank，每个 bank 4 字节。解决方法：调整数据布局加 padding（如 [N+1] 而非 [N]），或者 swizzle。
Q36. GPU 的两种瓶颈是什么？
Q37. GPU 运行的时候是如何将数据从 CPU 搬到 GPU 的？
通过 PCIe 总线进行的跨域传输。
流程：
Host 上分配 pinned memory（避免 swap）
cudaMemcpyAsync 把数据 DMA 拷贝到 GPU 显存
配合 CUDA Stream 实现拷贝与计算 overlap
现代架构有 NVLink / GPUDirect 可以绕过 CPU
Q38. 如何理解 CPU 和 GPU 的内存层次？
CPU：设计目标是最小化单线程延迟——通过 L1/L2 应对局部性，L3 解决多核数据共享与内存墙问题。深层 cache 是核心。
GPU：专注吞吐量优化——凭借海量线程隐藏延迟，显存带宽优势和大规模寄存器资源使其无需深度缓存层级。层级是 Register → SMEM/L1 → L2 → HBM。
二者差异本质是在延迟敏感与吞吐优先之间的架构权衡。
Q39. 如何优化 RMSNorm 算子？解决什么瓶颈？
RMSNorm 是 Memory-Bound（计算量小，但要读整个 hidden state）。
优化手段：
算子融合：和前后的 residual / linear 融合，减少 HBM 往返
vectorized load：float4 加载
warp-level reduction：用 __shfl_xor_sync 做归约，避免 SMEM 同步
block-level 时：先 warp reduce，再 SMEM 跨 warp 聚合
单步算 sum(x²)，避免 mean/var 两遍扫数据
Q40. 你会用 ncu 优化性能，会关注哪些指标？
SM Occupancy：占用率
Memory Throughput / DRAM Throughput：访存带宽利用率
Compute (SM) Throughput：算力利用率
L1/L2 Cache Hit Rate
Warp Stall Reasons：哪种原因导致 stall（long scoreboard / barrier / mio_throttle…）
Achieved vs Theoretical Bandwidth
Roofline 分析：判断 kernel 是 Compute-Bound 还是 Memory-Bound
根据指标判断：
Q41. Latency Bound 问题、Occupancy 相关问题？
Q42. Ada 升级到 Blackwell 架构，软硬件层面有哪些变化？
硬件层面：
Q43. 嵌入式平台/资源受限平台部署小模型vsGPU大模型推理的区别？
可复用：
量化（INT8/INT4）思路
算子融合
KV cache 优化
整体的推理流水线设计
需要注意的差异：
Q44. 你是用什么方法解决数据搬运和提高速度的？
Q45. PyTorch 显存管理是怎么做的？
PyTorch 用 caching allocator：
第一次申请向 CUDA 要大块（按 2MB / 20MB 分级）
释放时不还给 CUDA driver，而是放回内部 free list
下次申请优先从 free list 复用，按 size 匹配
这样避免频繁 cudaMalloc/cudaFree 的高开销
副作用：nvidia-smi 看到的显存比实际占用高
Q46. 有做过 PyTorch 自定义算子吗？
典型路径：写CUDA kernel → C++ wrapper → TORCH_LIBRARY 注册 → Python端torch.ops.mylib.myop调用；或者用 torch.utils.cpp_extension.load_inline
Q47. 之前有做过建模类型的工作吗？分层看激活值的优化？
思路：用hook注入每层激活，统计 min/max/distribution，对比量化前后的差异，定位敏感层
Q48. llama.cpp 是不是只是单 batch 的情况？
历史上是单 batch 为主（端侧场景为主），但目前已经支持 batched decoding（llama_batch）和并行序列。不过相比vLLM这类serving框架，它的多batch调度仍然较为简单。
Q49. llama.cpp 除了算子优化以外，还有什么方法降低延迟？核心优化能力是什么？
K-Quant 系列量化（Q2_K ~ Q8_K，超块 + 子块两级量化）
GGUF 格式：mmap 直接加载，减少冷启动时间 CPU + GPU 混合推理（-ngl 控制 offload 层数）
持续 batch 优化
prompt cache：相同 prompt 复用 KV 跨平台 backend：Metal / CUDA / SYCL / Vulkan
核心优化能力：极致的端侧量化部署+跨平台兼容+极小依赖（纯 C/C++）。
Q50. K-Quant 量化方法是什么？
量化流程（4 步）：
分块：权重矩阵按行优先展平，每 256 维为一个超块，再拆为 8 个 32 维子块
算局部参数：对每个 32 维子块，用 make_qkx1_quants（5 次迭代 K-Means）求最优 scale/min，最小化重构误差
算全局参数：取 8 个子块的最大 scale 作为全局 scale（d = max_scale / 63），最大 min 作为全局 min 尺度（dmin = max_min / 63）
编码存储：
反量化（推理时）：
对每个 32 维子块：
从 scales 解码 6-bit scale/min，乘全局 d/dmin 得实际 scale/dm
解包 4-bit 权重（q = (qs[l] & 0xF) 或 (qs[l] >> 4)）
反量化：x = d * q - dm（FP16 计算）
Q51. llama.cpp 里比较精妙的技巧是什么？
GGUF + mmap：模型按需加载，启动快、内存可被多进程共享
Q-format 的紧凑编码：scale 和量化值的 packing 设计极致省内存
统一的 ggml 张量抽象：跨后端只换 backend op
SIMD 内核手工优化：每种量化格式都有 AVX2/AVX-512/NEON/Metal/CUDA 的专门实现
graph 重用 + scratch buffer：每步推理复用同一块工作内存
Q52. FLOPS 和 FLOPs 和吞吐量分别是什么？
FLOPS（Floating Point Operations Per Second，每秒浮点运算次数）：
衡量硬件理论峰值计算能力的标准单位
比较不同硬件理论算力天花板的主要指标
常用 TFLOPS、PFLOPS 表示
FLOPs（Floating Point Operations，浮点运算次数）：
吞吐量（Throughput）：
文章来源：@张朱墨Jum0R 知乎作者授权分享 https://zhuanlan.zhihu.com/p/2031444649823449112
10个月宝宝每天需要喝多少奶粉？
