所谓对称量化：零点就是0，不需要平移因子，计算量更小;
非对称量化：需要引入平移因子，计算量更大。
量化粒度：

X*W: 对于激活一般是per-tensor * pertensor 或者 per-token * per-channel （行与列切分）

离群值:某些元素的数值明显高于其他维度平均值的情况(通常为5倍以上)。离群值会扩大量化步长,从而导致显著的精度损失；
离群值基本是基于channel的。我们发现激活难量化，权重分布更均匀，容易量化。
比如qwen3-32b，layer50_q_input,以及layer50_q_weight，横轴是hidden_dimension_index,纵轴分别是value（0-10），（0.0-0.3）。layer63_k_input,以及layer63_k_weight。

1. 统计：跑少量校准数据，统计每一层激活值 $X$ 的逐通道最大绝对值，作为该通道的"显著度"指标。
2. 计算缩放因子：基于激活显著度，为每个输入通道计算保护系数
   $$s = \left(\frac{\max(|X|)}{\text{mean}(\max(|X|)) + \epsilon}\right)^\alpha$$
   （$\alpha$ 通常取 0.5~1.0，控制保护强度）。
3. 变换：在线下把权重变成 $\hat{W} = W \cdot \text{diag}(s)$，同时把激活变成 $\hat{X} = X \cdot \text{diag}(s)^{-1}$，等价于将量化难度从激活迁移到权重。
4. 分组量化：将权重按列分成若干组，每组内寻找最优的缩放和零点，对显著通道所在的组采用更精细的量化粒度。
5. 结果：显著权重获得更高有效精度，非显著权重被高度压缩，整体实现 W4A16 或 W4A4 量化，精度损失显著低于均匀量化方法

1. 层间解耦：将模型按层独立处理，固定其他层，只优化当前层的量化权重。
2. 构造目标函数：基于Hessian矩阵（激活的协方差近似），最小化量化前后的输出差异
   $$\min_{\hat{W}} |W X - \hat{W} X|_2^2$$
   其中 $X$ 是该层输入的激活矩阵。
3. 最优脑量化（OBQ）：逐列量化权重，将每列看作待量化的向量，其余列作为待定系数。
   • 对当前列 $w$ 寻找最优量化值 $\hat{w} = \text{round}(w / s) \times s$
   • 计算量化误差 $e = w - \hat{w}$
   • 将误差传播到未量化的列：$w_{\text{remaining}} -= e \cdot (H^{-1} H_{\text{remaining}})$
4. 平方根重构：为避免显式计算和存储庞大的Hessian逆矩阵，采用平方根分解进行数值稳定的逐列更新
   $$H = L L^T$$
   利用三角矩阵 $L$ 高效计算误差传播。
5. 分组量化：将权重按行分成若干组（如128列一组），每组共享缩放因子 $s$ 和零点 $z$，降低存储开销。
6. 结果：权重被量化为INT4/INT3/INT2，激活保持FP16，通过Hessian指导的误差补偿，在极低比特下仍保持较高精度，适合消费级GPU部署。

1. 问题识别：分析激活矩阵 $X$ 和权重矩阵 $W$，发现离群值往往集中在少数特定通道（如LLM中的"离群特征"），导致这些通道难以低比特量化。
2. 构造旋转矩阵：基于随机Hadamard矩阵或Householder反射，构造正交矩阵 $R$ 满足 $R^T R = I$。
3. 离线旋转权重：在量化前对权重进行旋转变换
   $$\hat{W} = W \cdot R$$
   将离群值从集中通道分散到所有通道。
4. 在线旋转激活：推理时对输入激活进行逆旋转（即正交转置）
   $$\hat{X} = X \cdot R^T$$
5. 融合归一化：将旋转矩阵与LayerNorm/RMSNorm的缩放参数融合，避免在线旋转的额外计算开销
   $$\text{LN}_{\text{fused}}(x) = R^T \cdot \text{diag}(\gamma) \cdot \frac{x - \mu}{\sigma}$$
6. 均匀量化：旋转后的激活和权重分布近似独立同分布（i.i.d.）高斯，通道间方差均衡，可直接应用逐通道或逐张量均匀量化。
7. 结果：无需分组量化或混合精度，实现W8A8甚至W4A4量化，离群值导致的量化误差被旋转分散吸收，精度显著优于直接量化，且推理延迟增加极小（旋转与归一化融合）。

1. 计算kl误差
   KL 误差 = 量化前后该层输出分布之间的 KL 散度（Kullback-Leibler divergence）。
   计算步骤

• 用一小批校准数据（通常 512~2048 条）跑 bf16 模型，收集该层输出特征图，得到真实分布 P。
• 用同一批数据跑 伪量化版本（权重按候选方案量化为 int 4/8 后再反量化），得到近似分布 Q。
• 逐通道统计直方图，计算
• KL(P‖Q) = Σ P(i) log(P(i)/Q(i))
• 值越大 → 量化后分布越偏离原分布，该层对量化越“敏感”。

把「一旦量化就会误差爆炸」的层/Token 标成「必须 bf16」；其余放心 INT4/8。将结果写进对应json文件中，sensitive_layers.json，一次生成，全生命周期复用。

2. 权重打包只留敏感层做 bf16，显存省 41 %，无翻倍。
   磁盘里同时存两份：

• INT8 权重
• 仅敏感层 bf16 权重
  加载时到同一块显存

3. 算子测适配fp16/int8
   适当在算子测加一些判断条件（算子测修改）
   用 64-bit 掩码当‘红绿灯’，让同一条kernel 在 layer/token/batch三个维度上细粒度地瞬间选 FP16 还是 INT8
   kernel 里加一条 if (mask & bit) fp16_matmul else int8_matmul，粒度可到层/Token/Batch；
   Triton 实现，延迟 <2 µs，占空比 <0.3 %。

4. 动态兜底
   修改vllm测的代码，包含attention.py，采集中间激活；
   vllm/dynamic_fallback.py-- 在线统计 + 触发回退；
   vllm/core/scheduler.py--掩码热插拔；
   vllm/kernels/custom_quant.py-- Kernel 侧读掩码。

在线统计每个请求的中间激活，若 KL>0.02立即把该请求剩余 Token 全部切 FP16，单条回退，不影响别人。
全程热插拔，无需重启服务。

核心架构对比

2. 具体实现过程 (Implementation Details)

3. 量化开关逻辑 (Quantization Switch Valve)

文件路径: ascend_vllm/model_executor/.../compressed_tensors.py

✅ 核心原则：“该快的快，该省的省，该融合的绝不拆散”。

4. 性能验证指标

5. 面试高频 Q&A

1. 为什么 INT8 能让“算力”省 40 % 在 NPU/GPU 里，矩阵乘的“算力”通常用 FLOPs（Floating-Point Operations） 当度量； FP16 GEMM 每做一次乘加算 2 FLOPs，INT8 GEMM 每做一次乘加算 1 ILOP（Integer Operation），而 ASCEND NPU 的 ILOP 吞吐正好是 FP 的 2×，且功耗更低； 30B 模型 prefill 阶段 90 % 时间花在 batch×seq×hidden² 的大形状 GEMM；换成 INT8 后，理论 FLOPs 减半，再刨掉 dequant/scale 的少量额外指令，实测 整体 math pipeline 节省约 40 % 的运算量； 因此“算力节省 40 %”是口语化表达，严谨说法应是 计算量 ↓40 % 或 math 利用率 ↓40 %。

2. 为什么TTFT只下降12%
   | 阶段 | 占比 | 量化收益 |
   | ------------------------------- | ---- | ------------------ |
   | 1. 调度器排队 + 采样层 prepare | 8 % | 0 |
   | 2. Embedding + Rotary + Mask 准备 | 7 % | 0 |
   | 3. Q/K/V/O 投影 GEMM（INT8） | 45 % | ↓40 % → 省 18 % 总时间 |
   | 4. Attention（FlashAttention） | 25 % | 0（KV 仍是 FP16） |
   | 5. FC1/FC2 MLP | 10 % | 0（未量化） |
   | 6. 通信 All-Gather + Reduce | 5 % | 0 |

只有 3. 受益，别的阶段纹丝不动；
45 % × 40 % = 18 %，再被其他 55 % 摊平，端到端 TTFT 实测 11 %~12 %；
若把 Attention、MLP、通信全部 INT8，理论可再降 20 %，但会引入肉眼可见的 ppl 上涨，目前方案只动 Q/K/V/O 投影，是性价比最优甜点区。

UMA：在传统单CPU主板的系统中，所有CPU核心通过一条总线共享同一块物理内存，访问延迟和带宽对所有核心都是均匀的。这就是“统一内存访问”。

NUMA：在多路服务器（例如，2路或4路CPU）中，每个CPU（通常称为一个NUMA节点）拥有自己本地的物理内存和内存控制器。CPU访问自己的本地内存非常快。同时，它也可以通过系统互联（如AMD的Infinity Fabric、Intel的QPI/UPI）访问其他CPU的远端内存，但访问延迟更高、带宽更低。

NUMA优化的目标就是 “让任务和数据待在同一个家里”：

将进程绑定到某个特定的NUMA节点上的CPU核心。
同时要求该进程分配的内存也来自该节点的本地内存。
这样就能确保绝大部分内存访问都是本地访问，获得最低的延迟和最高的带宽。

步骤一：探测系统NUMA与硬件拓扑
这是最关键的准备步骤，目的是画出系统的“地图”。

1. 查看NUMA节点布局：
   bash
   numactl --hardware
2. 查找NPU卡与NUMA节点的亲和性：

首先，使用 npu-smi info 获取卡的Bus-ID。
然后，使用 lspci 查询该Bus-ID设备所在的NUMA节点。

获取NPU Bus-ID (例如：0001:74:00.0)
npu-smi info
查询该设备的NUMA节点
lspci -vs 0001:74:00.0 | grep NUMA

# 输出：0  (表示该卡亲和于NUMA Node 0)

原理：PCIe设备（包括NPU/GPU）会通过PCIe root complex连接到某个特定的CPU上。这个CPU所属的NUMA节点就是该设备的“本地节点”。从该节点访问设备，PCIe延迟最低。

步骤二：执行绑核与内存绑定
根据第一步探测到的信息，为每个进程（例如分布式训练的每个rank）制定绑定策略。

假设我们有2张卡，那么启动两个进程：
linux命令如下：
启动 Rank 0， 绑定到 NUMA Node 0， 使用 NPU 0
numactl --cpunodebind=0 --membind=0
python my_training_script.py --rank 0 --device 0
命令解释：
--cpunodebind=0：该进程的线程只能在NUMA Node 0的CPU核心（0-23）上运行。
--membind=0：该进程只能从NUMA Node 0分配内存。

步骤三：验证优化效果
检查进程绑定：

bash
找到进程PID
ps aux | grep "my_training_script.py"
查看该进程的CPU亲和性
taskset -cp
输出：pid 's current affinity list: 0-23 (应该只在绑定的节点核心上)
监控NUMA内存访问：
使用 numastat 命令查看系统级或进程级的NUMA内存分配情况。

对应linux命令
查看系统整体情况
numastat

查看特定进程的情况
numastat -p
优化前，你可能会看到 numa_miss（内存分配在了非本地节点）很高。优化后，numa_hit 会占绝大多数，numa_miss 会非常低，这正是您提到的“跨节点内存访问减少60%”的体现。

1. 项目概况 (STAR 法则)

2. 核心优化维度对比表

3. 技术实现深潜 (Deep Dive)

3.1 调度器优化：从“事后救火”到“事前预算”

3.2 故障恢复：pd_link_down 快速失败机制

3.3 内存与格式：NZ 格式与零拷贝

4. 性能验证指标

5. 面试高频 Q&A

🔧 核心优化点对比表

1. PD 分离调度优化

…Q: 为什么组合块匹配要限制连续且递减？

A: PagedAttention 的 Block Table 要求逻辑块在物理上可离散，但同一序列的前缀块必须保持顺序。连续+递减校验确保复用的块序列与原始计算顺序完全一致，避免注意力计算错误。

关键修改文件
vllm/model_executor/layers/attention.py：修改TensorParallelAttention类的_forward方法，新增分布式Softmax逻辑。
vllm/attention/ops/flash_attention.py：修改FlashAttention算子的forward方法，支持局部QK计算和分布式Softmax校正

vLLM 0.11.0版本的方案二执行流程
以70B Qwen模型、张量并行度TP=8、序列长度S=10k、头维度D_head=128为例：

模型初始化：加载70B Qwen模型，张量并行切分K/V为S/TP=1250长度，Q保持完整（1×128）。
局部QK计算：每个TP rank计算1×1250的局部分数矩阵。
分布式Softmax：
局部计算max（1×1）和sum_exp（1×1）；
8个TP rank通过All-Reduce同步全局max和全局sum_exp；
校正局部分数为全局正确的概率（1×1250）。
局部Attention@V：每个TP rank使用校正后的局部概率与本地V计算1×128的局部输出。
全局归约：8个TP rank通过All-Reduce（sum）合并局部输出，得到最终1×128的全局输出。

对应结果：
短上下文（S<1k）：方案二的优势有限，仅通信量↓92%，但延迟和显存优化不明显，适合带宽受限的场景。
中/长上下文（S≥10k）：方案二是碾压级优势，通信量↓99%+，延迟↓36%-58%，显存↓5%-18%，是长上下文大模型推理的必选方案。

工程落地价值（以华为云服务为例）
服务容量提升：长上下文场景下，方案二的单卡服务容量从100并发提升至250并发（↑150%），因为显存占用降低且延迟缩短。
成本降低：相同服务规模下，方案二所需的NPU数量从16卡降至6卡（↓62.5%），年硬件成本节省约120万元。
用户体验优化：长文档摘要场景的响应时间从215ms降至89ms，达到“实时交互”标准（<100ms）。

二、关键指标的量化分析

1. 通信量优化（核心优势）
   方案一：通信量与序列长度S成正比（通信量 = S × D_head × 2（QK）× 4字节（FP16）/ TP）。例如S=100k时，通信量=100k×128×2×4B/8=1.28GB。
   方案二：通信量与头维度D_head成正比（通信量 = D_head × 2（max+sum）× 4字节（FP16）× TP）。例如D_head=128时，通信量=128×2×4B×8=0.001GB。
   长上下文场景：方案二的通信量几乎可忽略，彻底解决长上下文的带宽瓶颈。
2. 推理延迟优化
   短上下文：方案二的延迟优势不明显（仅↓5.6%），因为通信量本身较小，分布式Softmax的计算开销抵消了部分收益。
   长上下文：方案二的延迟↓58.6%，因为通信量从1.28GB降至0.001GB，通信延迟占比从60%降至1%以下。
3. 显存占用优化
   方案一：需预分配全局KV-Cache内存（如S=100k时，KV-Cache内存=100k×128×2×4B=100MB/头，8头则800MB），但因碎片率高（如95%），实际显存占用达35.7GB。
   方案二：通过分布式Softmax减少全局内存分配，碎片率降至2.6%，显存占用仅29.1GB，节省18.49%。

TP+DP 是基础的并行策略：
DP (Data Parallelism)：负责扩展 Batch Size，通过复制模型副本处理不同数据。
TP (Tensor Parallelism)：负责拆分大模型参数（按隐藏层维度 H 切分），以适配单卡显存限制。
核心痛点：
纯 TP+DP 在处理 长序列 (Long Context) 时存在致命弱点：激活值 (Activations) 和某些无权重算子（如 LayerNorm, Dropout）的显存占用无法随 TP 度增加而减少。每个 GPU 仍需存储完整的序列长度。

解决方案：
引入 SP (Sequence Parallelism)。
本质：SP 是 TP 的增强版，它在 TP 组内部进一步将序列维度S进行切分。
目标：让激活值显存也能随并行度线性降低，从而支持超长上下文。

具体的算子切分对比如下：

1. 线性层 (QKV Projection / MLP)

2. attention层

3. 归一化与丢弃 (LayerNorm & Dropout)

🚀 并行策略高频面试快查 (Q1-Q4)

Q1: TP 和 EP 能一起用吗？

• 结论：✅ 可以组合。
• 原理：切分维度正交（TP 切算子内部 Head/权重，EP 切专家维度）。
• 约束：TP_SIZE × EP_SIZE ≤ 总卡数，且通信组需隔离（避免 All-Reduce 与 All-to-All 冲突）。
• NPU 要点：权重预转 Fractal_NZ，EP 通信启用异步模式。

Q2: PP 的 Bubble 怎么优化？

• 增加微批次：Micro-batch 数 ≥ PP_SIZE，填充流水线间隙。
• 计算通信重叠：使用 npu_stream 并行执行层间通信与计算。
• 负载均衡：确保各 Stage 层数/计算量相近，避免木桶效应。
• 公式：Bubble 比例 ≈ (PP_SIZE - 1) / (PP_SIZE × Micro-batch)。

Q3: 为什么 CP 优选分布式 Softmax 方案？

• 通信量级：传统方案 O(S)（传全序列分数）vs 分布式方案 O(1)（仅传最大值/指数和）。
• 长序列优势：128k 序列下，通信量降低数万倍。
• 计算并行：Softmax 与 Attention@V 分布式执行，算力利用率更高。
• 关键：需定制 Kernel 保证数值稳定性（Log-Sum-Exp）。

Q4: EP 的 All-to-All 为什么是瓶颈？如何优化？

• 瓶颈根源：全互联通信开销大 + Token 路由不均（负载倾斜）+ Kernel 下发频繁。
• 优化三板斧：
  1. 异步执行：用计算掩盖通信延迟。
  2. 融合 Kernel：路由 + 通信 + 计算打包，减少下发次数。
  3. 负载均衡：训练期加损失函数，推理期动态重路由。
• NPU 要点：强制使用 HCCL All-to-All 替代通用实现。

一、SpinQuant 速读（Meta 2024）

核心一句话
“把 QuaRot 的固定 Hadamard 旋转改成可学习旋转矩阵，用 Cayley 参数化 + 小校准集训练，4-bit 权重激活量化后平均 perplexity 比 QuaRot 再降 3-5 个点，推理零开销。”

我看重的三条细节

代码级启示

• 旋转矩阵用 CayleyMap 实现：R = (I - A)(I + A)⁻¹，保证可逆且正交，PyTorch 5 行搞定。
• 量化入口在 spinquant/rotate.py:rotate_weights_acts()，可一键套在任意 HuggingFace 模型上，我已给 Qwen-14B 跑通 4-bit，显存 6.9 GB → 2.1 GB，下降 69 %。

论文：SpinQuant: LLM Quantization with Learned Rotations (arXiv 2405.16406)
代码：https://github.com/facebookresearch/SpinQuant

二、近期大模型论文「快餐包」

三、日常信息源（公开可搜）

📚 公众号（按打开频率）

• AI 大模型前沿——量化/部署干货多，日更。
• 深度学习自然语言处理——论文速递+代码链接，早 8 点推送。
• 机器之心——行业大事件，融资、芯片、政策一站式。
• NVIDIA 开发者社区——官方 kernel 优化、CUDA 新特性首发。

📖 今年读完/在读的书

四、彩蛋：我常用的“论文 → 代码”三步

1. arXiv Daily 邮件 → 标题过滤“quantization/kv cache”
2. HuggingFace Papers 页面 → 直接点“Code”按钮跳 GitHub
3. GitHub 先看 requirements.txt → 判断 PyTorch 版本 ≤ 2.2 再 clone，避免环境地狱。

以上，既回答了 SpinQuant 的核心机制，也给了一份“大模型快餐书单”和日常信息源，希望能帮你在面试/技术交流里快速抛出“有数字、有代码、有体感”的观点。

排序算法
排序算法是计算机科学中非常基础且重要的一类算法，用于将一组数据按照特定的顺序（通常是升序或降序）进行排列。以下是一些常见的排序算法及其原理：

1. 冒泡排序（Bubble Sort）

• 原理：通过重复遍历要排序的数列，比较每对相邻元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
• 时间复杂度：平均和最坏情况为 O(n^2)，最好情况为 O(n)。
• 空间复杂度：O(1)。
• 稳定性：稳定。

2. 选择排序（Selection Sort）

• 原理：首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
• 时间复杂度：O(n^2)。
• 空间复杂度：O(1)。
• 稳定性：不稳定。

3. 插入排序（Insertion Sort）

• 原理：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
• 时间复杂度：平均和最坏情况为 O(n^2)，最好情况为 O(n)。
• 空间复杂度：O(1)。
• 稳定性：稳定。

4. 希尔排序（Shell Sort）

• 原理：是插入排序的一种更高效的改进版本。希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了。
• 时间复杂度：取决于步长序列，平均为 O(n log n)。
• 空间复杂度：O(1)。
• 稳定性：不稳定。

5. 归并排序（Merge Sort）

• 原理：采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。将数组分解到最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
• 时间复杂度：O(n log n)。
• 空间复杂度：O(n)。
• 稳定性：稳定。

6. 快速排序（Quick Sort）

• 原理：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
• 时间复杂度：平均为 O(n log n)，最坏情况为 O(n^2)。
• 空间复杂度：O(log n)。
• 稳定性：不稳定。

7. 堆排序（Heap Sort）

• 原理：利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
• 时间复杂度：O(n log n)。
• 空间复杂度：O(1)。
• 稳定性：不稳定。

8. 计数排序（Counting Sort）

• 原理：不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
• 时间复杂度：O(n + k)，其中 k 是数据范围。
• 空间复杂度：O(k)。
• 稳定性：稳定。

9. 桶排序（Bucket Sort）

• 原理：将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。
• 时间复杂度：平均为 O(n + k)，最坏情况为 O(n^2)。
• 空间复杂度：O(n + k)。
• 稳定性：稳定。

10. 基数排序（Radix Sort）

• 原理：按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。
• 时间复杂度：O(nk)，其中 k 是数字的最大位数。
• 空间复杂度：O(n + k)。
• 稳定性：稳定。

总结

• 时间复杂度：O(n log n) 的算法有归并排序、堆排序、快速排序等。
• 稳定性：稳定的排序算法包括冒泡排序、插入排序、归并排序、计数排序、桶排序和基数排序等。
• 空间复杂度：O(1) 的算法包括冒泡排序、选择排序、插入排序、希尔排序和堆排序等。