第2章：算法与算子分析

YOLOv1 (2016)              YOLOv3 (2018)              YOLOv5-8 (2020-2023)
     │                          │                              │
     ▼                          ▼                              ▼
┌─────────┐              ┌──────────────┐            ┌──────────────────┐
│全连接输出│              │多尺度FPN输出│            │解耦检测头+Anchor │
│7×7×30   │              │13×13,26×26,  │            │Free设计          │
│         │              │52×52         │            │                  │
└─────────┘              └──────────────┘            └──────────────────┘
     │                          │                              │
     ▼                          ▼                              ▼
内存瓶颈:                 计算分散:                    硬件友好:

- FC层参数量大            - 3个独立head                - 统一的检测流程
- 固定输入尺寸            - 不同stride特征             - 规则的tensor操作
- 低分辨率限制            - anchor匹配开销             - 易于量化和剪枝

这种设计使得整个Bottleneck可以在单次数据加载后完成计算，极大降低了DDR带宽压力。对于典型的C=256通道，80×80特征图，单个Bottleneck仅需6.5MB的DDR访问，而计算量达到0.66 GFLOPs，算术强度高达101 ops/byte。

2. **Anchor-free检测头**：相比YOLOv5的anchor-based方法，YOLOv8采用了解耦检测头（Decoupled Head），将分类和回归任务分离：
$$\text{Det}\_{\text{cls}} = \text{Conv}\_{3 \times 3}(\text{Conv}\_{3 \times 3}(F)) \in \mathbb{R}^{H \times W \times N\_{\text{cls}}}$$
$$\text{Det}\_{\text{reg}} = \text{Conv}\_{3 \times 3}(\text{Conv}\_{3 \times 3}(F)) \in \mathbb{R}^{H \times W \times 4}$$
解耦设计允许独立优化两个分支的量化策略。分类分支可以使用INT8量化（对类别预测的微小偏差不敏感），而回归分支保持FP16以确保边界框的精确定位。

**硬件映射优化**：

计算密度 (ops/byte)
200 ┤                                    ╱─── Stage 5 (Compute-bound)
    │                                 ╱╱╱    适合稀疏化
150 ┤                            ╱╱╱╱╱
    │                       ╱╱╱╱╱        ← AI_ridge = 100
100 ┤──────────────────╱╱╱╱╱─────────────── (200TOPS/2TB/s)
    │              ╱╱╱╱╱ Stage 3-4
 50 ┤         ╱╱╱╱╱      (Balanced)        
    │    ╱╱╱╱╱           适合脉动阵列
 10 ┤╱╱╱╱ Stage 1-2 (Memory-bound)
    │     需要带宽优化
  0 └────┬────┬────┬────┬────┬────┬────
      P1/2  P2/4  P3/8 P4/16 P5/32 Head
                  Network Depth →

if (Density < 20) {
    // Memory-bound: 使用更多的内存通道，降低计算并行度
    配置: 4个内存通道, 1/4计算阵列
} else if (Density < 80) {
    // Balanced: 平衡配置
    配置: 2个内存通道, 1/2计算阵列
} else {
    // Compute-bound: 最大化计算资源
    配置: 1个内存通道, 全部计算阵列
}

Input Feature Map (20×20×1024)
        │
        ├─────────────────────────────────┐ (直通)
        │                                 │
        ▼                                 │
   MaxPool_5×5 ──────────────┐           │
        │                     │           │
        ▼                     │           │
   MaxPool_5×5 ────┐         │           │
        │           │         │           │
        ▼           ▼         ▼           ▼
   MaxPool_5×5 → Concat → Concat → Concat → Output
                                   (20×20×4096)

内存需求对比：

- SPP (并行): 4×20×20×1024×2 = 3.2MB
- SPPF (串行): 1×20×20×1024×2 = 0.8MB
- 节省75%片上存储

热图尺寸: 160×160×80 (80个类别)
总位置数: 25,600
典型目标数: 20-30
稀疏度: 1 - 30/25600 = 99.88%

内存占用对比:
密集表示: 160×160×80×4 = 8.2MB (fp32)
稀疏表示: 30×(2+1+80×4) ≈ 10KB
压缩率: 820:1

对于不同尺寸的目标，σ的典型值：

- 行人 (40×100 pixels): σ ≈ 2.1
- 轿车 (150×300 pixels): σ ≈ 7.9  
- 卡车 (200×500 pixels): σ ≈ 14.9

预计算策略：

1. 离散化σ为16个等级
2. 每个等级存储7×7的高斯模板
3. 总存储: 16×7×7×4 = 3.1KB
4. 渲染时直接查表，避免exp计算

Heat Map (160×160×80)
        │
        ▼
MaxPool_3×3 (same padding)
        │
        ▼
Element-wise Compare with Original
        │
        ▼
Threshold (>0.3)
        │
        ▼
Extract Coordinates

并行度分析：

- MaxPool: 完全并行，O(1)时间复杂度
- Compare: SIMD并行，25,600个位置同时比较
- Extract: 稀疏gather操作

相比NMS的O(N²)复杂度，提速100倍以上

Backbone Features (C channels)
        ↓
   Conv 3×3 (256 channels)
        ↓
   ┌────┴────┬────────┬──────────┐
Heatmap   Offset    Size      3D Extension
(K cls)   (2 ch)   (2 ch)     (optional)

方法对比           PointNet++        PointPillars
────────────────────────────────────────────────
输入格式           不规则点集         规则Pillar Grid
内存访问模式       随机访问          顺序访问
并行化难度         高(FPS/采样)      低(规则tensor)
硬件利用率         ~30%             ~85%
推理延迟(ms)       67               16
内存带宽需求       不可预测          可精确计算
缓存命中率         <40%             >90%

for each pillar (x_p, y_p):
    points = find_points_in_pillar(x_p, y_p)
    if len(points) > N:
        points = random_sample(points, N)  # 随机采样保持代表性
    elif len(points) < N:
        points = pad_with_zeros(points, N)  # 零填充保持tensor规则

距离范围     平均点数/pillar   稀疏度    优化策略
─────────────────────────────────────────────
0-10m       45.2            5%       完整处理
10-20m      18.7            15%      标准处理
20-40m      5.3             60%      稀疏处理
40-60m      1.8             85%      极稀疏处理
60m+        0.4             95%      跳过或简化

分级处理策略:
if (distance < 20m) {
    N_max = 100;  // 完整容量
    use_full_pointnet();
} else if (distance < 40m) {
    N_max = 32;   // 降低容量
    use_lite_pointnet();
} else {
    N_max = 8;    // 最小容量
    use_micro_pointnet();
}

点云密度分布图 (俯视图)

     近距离区域                中距离区域              远距离区域
   ┌───────────┐           ┌───────────┐         ┌───────────┐
   │███████████│           │░░░█░░█░░░░│         │····█······│
   │███████████│           │░████████░░│         │··█████····│
   │████ ██████│           │░░░█░░█░░░░│         │···█··█····│
   └───────────┘           └───────────┘         └───────────┘
  ~5000 pts/m²             ~500 pts/m²            ~50 pts/m²
  30% 空白pillars          90% 空白pillars        95% 空白pillars

active_pillars = get_non_empty_pillars()
batched_features = pointnet(active_pillars)
scatter_to_bev(batched_features, indices)

2. **稀疏卷积实现**：
- 使用CSR格式存储稀疏特征图
- Rulebook生成：预计算卷积核的有效位置
- Gather-GEMM-Scatter模式执行

3. **混合精度策略**：
- PointNet层：FP16（特征提取）
- BEV backbone：INT8（2D卷积）
- Detection head：FP16（精确定位）

#### CenterPoint的多尺度特征聚合

CenterPoint将CenterNet的思想扩展到3D空间，通过在BEV视角下检测目标中心实现高效的3D检测。其核心创新在于使用3D稀疏卷积处理体素化点云，然后在BEV空间进行中心点检测。

**三阶段处理流程：**

Raw Points (~100K points)
    ↓
[Stage 1: Voxelization]
Voxel Grid (40000×1600×40)
    ↓
[Stage 2: 3D Sparse CNN]
3D Features → BEV Compression
    ↓
[Stage 3: 2D Detection]
Center Heatmap + 3D Attributes

**体素化与3D稀疏卷积：**

1. **动态体素化**：
$$V\_{ijk} = \\{p | \lfloor\frac{p\_x}{\Delta\_x}\rfloor=i, \lfloor\frac{p\_y}{\Delta\_y}\rfloor=j, \lfloor\frac{p\_z}{\Delta\_z}\rfloor=k\\}$$
典型参数：

   - 体素大小：$[0.075, 0.075, 0.2]m$
   - 范围：$[-54, 54]m \times [-54, 54]m \times [-5, 3]m$
   - 体素网格：$1440 \times 1440 \times 40$

   **体素大小的权衡**：

2. **3D稀疏卷积网络**：

   SubMConv3d保持稀疏性，SparseConv3d允许稀疏性变化。

**稀疏卷积的高效实现：**

传统密集3D卷积的计算复杂度：
$$\text{FLOPs}\_{\text{dense}} = K^3 \times C\_{in} \times C\_{out} \times D \times H \times W$$
稀疏卷积通过Rulebook优化：
$$\text{FLOPs}\_{\text{sparse}} = \sum\_{(i,o) \in \text{Rulebook}} K^3 \times C\_{in} \times C\_{out}$$
实际加速比：
$$\text{Speedup} = \frac{1}{(1-\text{Sparsity})^2 \times \alpha}$$
其中 $\alpha \approx 1.2$ 为索引开销系数。对于95%稀疏度：
$$\text{Speedup} = \frac{1}{0.05^2 \times 1.2} \approx 333×$$
**Rulebook生成算法**：

这种方法将不规则的3D卷积转化为规则的GEMM操作，非常适合脉动阵列加速。

**BEV特征压缩：**

将3D特征压缩到BEV平面：
$$F\_{\text{BEV}}(x,y) = \text{Concat}\_{z}[F\_{3D}(x,y,z)]$$
或使用加权聚合：
$$F\_{\text{BEV}}(x,y) = \sum\_{z} w\_z \cdot F\_{3D}(x,y,z)$$
**多任务检测头：**

CenterPoint的检测头预测多个任务：

1. **中心热图**：$H \in \mathbb{R}^{W \times H \times K}$（K个类别）
2. **中心偏移**：$O \in \mathbb{R}^{W \times H \times 2}$（亚像素精度）
3. **3D尺寸**：$S \in \mathbb{R}^{W \times H \times 3}$（长宽高）
4. **旋转角度**：$R \in \mathbb{R}^{W \times H \times 2}$（sin, cos编码）
5. **速度估计**：$V \in \mathbb{R}^{W \times H \times 2}$（可选，用于跟踪）

**两阶段精炼（可选）：**

第二阶段使用RoI特征精炼预测：
$$\text{RoI Features} = \text{RoIAlign}(F\_{\text{BEV}}, \text{Proposals})$$
$$\Delta = \text{MLP}(\text{RoI Features})$$
精炼带来~2-3% AP提升，但增加20%延迟。

**计算复杂度分析：**

| 组件 | FLOPs | 占比 |

| 组件 | FLOPs | 占比 |
|------|-------|------|
| 3D Sparse CNN | 5.2G | 45% |
| BEV Backbone | 4.8G | 42% |
| Detection Heads | 1.5G | 13% |
| 总计 | 11.5G | 100% |

相比PointPillars（~63G），CenterPoint通过稀疏卷积实现5×加速。

### 2.1.3 BEV感知网络：BEVFormer与BEVDet

#### BEVFormer的时空注意力机制

BEVFormer通过可学习的BEV queries与多视角图像特征交互，实现2D到3D的特征转换。

**空间交叉注意力（SCA）：**
$$\text{SCA}(Q\_p, F\_t) = \sum\_{i=1}^{N\_{\text{ref}}} \text{DeformAttn}(Q\_p, P(p, i, j), F\_t^i)$$
其中：

- $Q\_p$: BEV位置 $p$ 的query
- $F\_t^i$: 第 $i$ 个相机在时刻 $t$ 的特征
- $P(p, i, j)$: 3D到2D的投影函数

**时序自注意力（TSA）：**
$$\text{TSA}(Q\_t, B\_{t-1}) = \text{DeformAttn}(Q\_t, Q\_t + \Delta, B\_{t-1})$$
这里 $\Delta$ 编码了自车运动补偿。

**计算开销分解：**

- SCA: $O(N\_{\text{BEV}} \times N\_{\text{cam}} \times N\_{\text{ref}} \times D^2)$
- TSA: $O(N\_{\text{BEV}} \times N\_{\text{temporal}} \times D^2)$
- 总计: 约30 GFLOPs用于6相机输入

#### BEVDet的深度估计策略

BEVDet通过显式深度估计构建BEV特征：

**深度分布预测：**
$$D(u,v) = \text{Softmax}(\text{Conv}(F\_{2D}(u,v))) \in \mathbb{R}^{D\_{\text{bins}}}$$
**Lift-Splat变换：**
$$F\_{\text{BEV}}(x,y) = \sum\_{c=1}^{N\_{\text{cam}}} \sum\_{d=1}^{D\_{\text{bins}}} F\_{2D}^c(\pi\_c(x,y,d)) \times D^c(\pi\_c(x,y,d))$$
其中 $\pi\_c$ 为相机 $c$ 的投影矩阵。

### 2.1.4 轨迹预测与规划网络

#### 基于Transformer的轨迹预测

现代轨迹预测网络（如Wayformer）采用场景中心（scene-centric）表示：

**场景表示的演进**：

从早期的独立轨迹预测到现代的交互式预测，架构设计经历了根本性变革：

Transformer架构在轨迹预测中的优势在于其能够捕捉复杂的多体交互模式，特别是在交叉路口、并线等高交互场景。

**Agent-Scene交互建模：**
$$h\_i^{(l+1)} = h\_i^{(l)} + \text{MHA}([h\_i^{(l)}, E\_{\text{pos}}^i], [H^{(l)}, E\_{\text{pos}}])$$
其中：

- $h\_i$: agent $i$ 的隐状态
- $E\_{\text{pos}}$: 位置编码
- $H$: 所有agents和地图元素的特征集合

**多模态轨迹生成：**
$$P(Y|X) = \sum\_{k=1}^{K} w\_k \cdot \mathcal{N}(\mu\_k(X), \Sigma\_k(X))$$
典型设置 $K=6$ 个模态，每个模态预测 $T=80$ 个时间步（8秒）。

**多模态的物理意义**：

不同模态对应不同的驾驶意图：

这种多模态设计对NPU的挑战在于需要并行计算6个不同的轨迹假设，每个假设都需要完整的前向传播。通过批处理和权重共享，可以将计算开销从6倍降低到2-3倍。

**计算需求：**

- Attention计算: $O(N^2 \times T \times D)$, 其中 $N \approx 200$ (agents + map)
- MLP解码: $O(K \times N \times T \times D^2)$
- 总计: 约5 GFLOPs per scene

## 2.2 VLM/VLA工作负载特征

视觉语言模型（VLM）和视觉语言动作模型（VLA）代表了多模态AI的前沿，其计算特征与传统CV网络有显著差异。

### 2.2.1 CLIP与对比学习的计算需求

#### CLIP的双塔架构

CLIP通过对比学习对齐视觉和文本表示，其架构设计充分考虑了大规模训练的效率需求：

**架构设计哲学：**

CLIP采用双塔架构而非融合架构的关键原因在于计算效率。在对比学习中，每个batch需要计算所有图像-文本对的相似度，双塔架构允许独立编码后仅需一次矩阵乘法，而融合架构需要 $B^2$ 次前向传播。这种设计在NPU上的优势包括：

1. **独立并行处理**：视觉和文本编码器可以部署在不同的计算单元上
2. **特征缓存复用**：编码后的特征可以缓存用于多次相似度计算
3. **灵活的批处理**：图像和文本可以使用不同的batch size优化吞吐量

**视觉编码器（ViT-L/14）：**
$$Z\_v = \text{ViT}(I) \in \mathbb{R}^{B \times D}$$
计算量分解：
$$\text{FLOPs}\_{\text{ViT}} = 2 \times N \times (D \times D\_{mlp} + N \times D^2/H)$$
其中：

- $N = (224/14)^2 = 256$ patches（14×14的patch划分）
- $D = 1024$ 隐藏维度（比ResNet的2048维更硬件友好）
- $D\_{mlp} = 4 \times D = 4096$（FFN扩展率）
- $H = 16$ 注意力头（每头64维，适合SIMD宽度）

总计约 81 GFLOPs。

**Patch Embedding的优化：**

将图像分割为patches的过程可以通过不同方式实现：
$$\text{Patch}(I) = \text{Reshape}(\text{Conv}\_{14 \times 14, \text{stride}=14}(I))$$
这个strided convolution在NPU上可以映射为：

- 内存重排操作（无计算）+ 矩阵乘法
- 或直接的大核卷积（需要专门的大核支持）

**文本编码器（Transformer）：**
$$Z\_t = \text{TextEncoder}(T) \in \mathbb{R}^{B \times D}$$
计算量相对较小（约 6 GFLOPs for 77 tokens）。

**对比损失计算：**
$$\mathcal{L} = -\frac{1}{2B}\sum\_{i=1}^{B}\left[\log\frac{e^{z\_v^i \cdot z\_t^i / \tau}}{\sum\_{j=1}^{B} e^{z\_v^i \cdot z\_t^j / \tau}} + \log\frac{e^{z\_t^i \cdot z\_v^i / \tau}}{\sum\_{j=1}^{B} e^{z\_t^i \cdot z\_v^j / \tau}}\right]$$
批量矩阵乘法需求：$Z\_v Z\_t^T \in \mathbb{R}^{B \times B}$

### 2.2.2 LLaVA与Flamingo的多模态架构

#### LLaVA的简单投影策略

LLaVA通过线性投影连接视觉编码器和语言模型：

**视觉特征投影：**
$$H\_v = W \cdot Z\_v, \quad W \in \mathbb{R}^{D\_{llm} \times D\_{vision}}$$
**多模态序列构建：**
$$X = [\text{System}, H\_v, \text{User}, \text{Assistant}]$$
**计算分布：**

- Vision Encoder: 5.6 GFLOPs (CLIP ViT-L/14, 336×336)
- Projection: 0.01 GFLOPs
- LLM (7B): 14 GFLOPs per token
- 总推理: 约 20 GFLOPs for 100 tokens output

#### Flamingo的Perceiver Resampler

Flamingo通过Perceiver架构处理可变长度视觉输入：

**Perceiver交叉注意力：**
$$Q\_{\text{latent}} \in \mathbb{R}^{N\_q \times D}, \quad K\_V = \phi(X\_{\text{visual}}) \in \mathbb{R}^{N\_v \times D}$$
其中 $N\_q = 64$ 固定查询数，$N\_v$ 可变。

**Gated Cross-Attention到LLM：**
$$h' = h + \tanh(\alpha) \cdot \text{CrossAttn}(h, Z\_{\text{visual}})$$
门控机制 $\alpha$ 初始化为0，实现渐进式适应。

### 2.2.3 RT-1/RT-2机器人控制模型

#### RT-1的实时控制架构

RT-1 (Robotics Transformer 1) 将机器人控制建模为序列决策问题：

**输入表示：**
$$X\_t = [\text{Image}\_t, \text{Language}, \text{State}\_t]$$
其中：

- $\text{Image}\_t \in \mathbb{R}^{300 \times 300 \times 3}$: RGB观察
- $\text{Language}$: 自然语言指令的embedding
- $\text{State}\_t \in \mathbb{R}^{8}$: 关节角度和夹爪状态

**动作tokenization：**
将连续动作离散化为256个bins：
$$a\_t = [\Delta x, \Delta y, \Delta z, \Delta\text{yaw}, \Delta\text{pitch}, \Delta\text{roll}, \text{gripper}]$$
**计算需求：**

- Vision: EfficientNet-B3, 1.8 GFLOPs
- Transformer: 8层, 2.5 GFLOPs  
- 动作解码: 0.1 GFLOPs
- 总延迟要求: < 100ms (10Hz控制)

#### RT-2的视觉-语言-动作统一

RT-2将预训练VLM适配为VLA，实现知识迁移：

**统一tokenization：**
$$\text{Vocab} = \text{Vocab}\_{\text{language}} \cup \text{Vocab}\_{\text{action}}$$
动作tokens作为特殊词汇：`<move_x_+10>`, `<rotate_z_-5>`等。

**Co-fine-tuning策略：**
$$\mathcal{L} = \lambda\_1 \mathcal{L}\_{\text{language}} + \lambda\_2 \mathcal{L}\_{\text{action}} + \lambda\_3 \mathcal{L}\_{\text{vision}}$$
保持多任务能力的同时学习控制。

**推理模式切换：**

- 语言生成: beam search, $B=4$
- 动作生成: greedy decoding, $B=1$
- 混合模式: 先生成语言reasoning，后生成动作

## 2.3 算子级性能分析

深入理解核心算子的计算特征是NPU优化的基础。本节量化分析GEMM、卷积、注意力等算子的性能特征。

### 2.3.1 GEMM的计算密度分析

#### 标准GEMM的算术强度

对于 $C = A \times B$，其中 $A \in \mathbb{R}^{M \times K}$, $B \in \mathbb{R}^{K \times N}$：

**计算量：**
$$\text{FLOPs} = 2MNK$$
**内存访问量（无重用）：**
$$\text{Memory} = (MK + KN + MN) \times \text{sizeof(dtype)}$$
**算术强度（Arithmetic Intensity）：**
$$AI = \frac{2MNK}{(MK + KN + MN) \times \text{sizeof(dtype)}}$$
对于方阵 $M=N=K$：
$$AI = \frac{2K}{3 \times \text{sizeof(dtype)}}$$
**nvfp4 (E2M1)影响：**

- sizeof(nvfp4) = 0.5 bytes
- $AI\_{\text{nvfp4}} = 2 \times AI\_{\text{fp8}}$
- 理论峰值提升，但精度损失需权衡

#### Batch GEMM的优化机会

批量矩阵乘法 $C\_i = A\_i \times B\_i$ for $i \in [1, B]$：

**数据重用分析：**

1. **Weight-stationary (B相同)**：
$$\text{Reuse}\_B = B$$
适用于全连接层推理

2. **Input-stationary (A相同)**：
$$\text{Reuse}\_A = B$$
适用于多头注意力的QKV投影

3. **Output-stationary**：
   部分和累加，减少输出带宽

### 2.3.2 Conv2D的内存访问模式

#### Im2col变换分析

Im2col将卷积转换为GEMM：

**展开后矩阵大小：**
$$\text{Im2col}: \mathbb{R}^{C\_{in} \times H \times W} \to \mathbb{R}^{(C\_{in} \times K\_h \times K\_w) \times (H\_{out} \times W\_{out})}$$
**内存膨胀率：**
$$\text{Expansion} = K\_h \times K\_w$$
对于3×3卷积，数据量增加9倍。

#### Direct Convolution的滑窗策略

直接卷积避免内存膨胀：

**计算循环嵌套：**

**Loop tiling优化：**
将循环分块以适配片上存储：
$$T\_h \times T\_w \times C\_{in} \times \text{sizeof(dtype)} \leq \text{SRAM}\_{\text{size}}$$
### 2.3.3 Attention的计算瓶颈

#### 标准Attention的二次复杂度

Self-attention计算：
$$\text{Attention}(Q,K,V) = \text{Softmax}\left(\frac{QK^T}{\sqrt{d}}\right)V$$
**计算复杂度：**

- QK矩阵乘: $O(N^2 \times d)$
- Softmax: $O(N^2)$
- Score×V: $O(N^2 \times d)$
- 总计: $O(N^2 \times d)$

**内存需求：**
存储attention矩阵需要 $N^2 \times \text{sizeof(dtype)}$ 字节。

对于序列长度 $N=2048$, fp16精度：
$$\text{Memory} = 2048^2 \times 2 = 8\text{MB}$$
#### Flash Attention的分块计算

Flash Attention通过分块降低内存访问：

**分块策略：**
将 $Q,K,V \in \mathbb{R}^{N \times d}$ 分为大小为 $B\_r \times d$ 和 $B\_c \times d$ 的块。

**Online softmax：**
$$m^{(j+1)} = \max(m^{(j)}, \tilde{m}^{(j)})$$
$$l^{(j+1)} = e^{m^{(j)} - m^{(j+1)}} l^{(j)} + e^{\tilde{m}^{(j)} - m^{(j+1)}} \tilde{l}^{(j)}$$
**IO复杂度降低：**
$$\text{IO}\_{\text{Flash}} = O\left(\frac{N^2d}{M^{1/2}}\right)$$
其中 $M$ 为SRAM大小。相比标准attention的 $O(N^2d)$，显著降低。

### 2.3.4 Memory-bound vs Compute-bound分析

#### Roofline模型应用

性能上界由计算能力和内存带宽共同决定：
$$\text{Performance} = \min(\text{Peak\_FLOPS}, AI \times \text{Bandwidth})$$
**分界点：**
$$AI\_{\text{ridge}} = \frac{\text{Peak\_FLOPS}}{\text{Bandwidth}}$$
对于200 TOPS NPU with 1TB/s带宽：
$$AI\_{\text{ridge}} = \frac{200 \times 10^{12}}{1 \times 10^{12}} = 200 \text{ ops/byte}$$
#### 典型算子分类

**Compute-bound算子：**

- 大矩阵GEMM: $AI > 100$
- 1×1卷积with大通道数: $AI \approx C\_{in}$
- 标准3×3卷积: $AI \approx 50-100$

**Memory-bound算子：**

- Element-wise操作: $AI < 1$
- Pooling层: $AI \approx 0.5$
- Normalization: $AI \approx 2$
- 小矩阵GEMM: $AI < 50$

#### 2:4稀疏对性能的影响

结构化稀疏改变计算密度：

**有效算术强度：**
$$AI\_{\text{sparse}} = \frac{AI\_{\text{dense}}}{2} \times \frac{1}{0.75}$$
压缩率50%，但索引开销25%。

**稀疏加速条件：**
$$\text{Speedup} > 1 \iff AI\_{\text{dense}} > 2 \times AI\_{\text{ridge}}$$
仅对compute-bound算子有效。

### 2.3.5 算子融合机会识别

#### 垂直融合（Producer-Consumer）

连续算子融合减少中间结果的内存访问：

**Conv-BN-ReLU融合：**
原始计算：

1. $Y = \text{Conv}(X, W) + b$
2. $Z = \gamma \frac{Y - \mu}{\sqrt{\sigma^2 + \epsilon}} + \beta$
3. $A = \max(0, Z)$

融合后：
$$A = \max\left(0, \gamma \frac{\text{Conv}(X, W) + b - \mu}{\sqrt{\sigma^2 + \epsilon}} + \beta\right)$$
**内存节省：**

- 原始: 3次feature map读写
- 融合: 1次读写
- 带宽降低: 67%

#### 水平融合（并行算子）

并行执行多个独立算子：

**多头注意力的QKV投影：**
$$Q = XW\_Q, \quad K = XW\_K, \quad V = XW\_V$$
融合为单个GEMM：
$$[Q, K, V] = X[W\_Q, W\_K, W\_V]$$
**优势：**

- 输入数据重用3倍
- 更好的矩阵维度for tiling
- 减少kernel启动开销

#### 图级优化机会

**Transformer块的端到端融合：**