如果你在昇腾上跑大语言模型，有一个库你一定绕不过去：ATB（Ascend Transformer Boost）。

ATB 是昇腾官方的 Transformer 专用加速库，专门给 Transformer 类模型提供端到端的加速能力。它不是简单的算子集合，而是一套完整的加速框架——从底层算子到图优化再到插件机制，三层架构层层递进。

这篇文章把 ATB 讲透。

ATB 的三层架构

┌─────────────────────────────────────────────┐
│           第 3 层：Plugin 层                 │
│     高级优化：自动融合、算子选择、调度        │
├─────────────────────────────────────────────┤
│           第 2 层：图算子层                   │
│   融合算子：FlashAttention、MoE、LayerNorm  │
├─────────────────────────────────────────────┤
│           第 1 层：基础算子层                 │
│     原始算子：MatMul、GELU、Softmax、Conv   │
└─────────────────────────────────────────────┘

每一层解决的问题不同：

• 第 1 层：官方算子，性能已经很好，但缺乏针对 Transformer 的专门优化
• 第 2 层：把多个基础算子融合成一个，减少内存搬运
• 第 3 层：自动分析计算图，做更激进的优化和调度

第 1 层：基础算子层

这一层就是普通的 CANN 算子，通过 AscendCL 接口调用：

import torch
import torch.npu

# 基础算子调用
x = torch.randn(1, 512, 768).npu()

# LayerNorm
norm = torch.nn.LayerNorm(768).npu()
x = norm(x)

# GELU 激活
gelu = torch.nn.GELU().npu()
x = gelu(x)

# MatMul
weight = torch.randn(768, 768).npu()
x = torch.matmul(x, weight)

基础算子调用简单，但每个算子都要单独执行、单独读写显存。512 序列长度跑一次 Transformer Block，基础算子要跑十几次，显存带宽会成为瓶颈。

第 2 层：图算子层

图算子是把多个基础算子"捏成一个"：

from ascend_transformer_boost import FlashAttention, LayerNormGeluFusion

# FlashAttention：Q×K^T + Softmax + ×V 融合
flash_attn = FlashAttention(
    head_num=12,
    head_dim=64,
    scale=1.0 / 8.0  # 1/√d
)
output = flash_attn(q, k, v)

# LayerNorm + GELU 融合：一次计算完成两层
ln_gelu = LayerNormGeluFusion(eps=1e-6)
output = ln_gelu(x, weight, bias)

融合的好处：

融合模式	减少的 HBM 访问	性能提升
QKV Fusion	2 次	20-30%
FlashAttention	N² 次 → 1 次	2-3 倍
LayerNorm + GELU	1 次	15-25%
FNN 融合	2 次	20-30%

第 3 层：Plugin 层

Plugin 是 ATB 最强大的地方。它能自动分析模型计算图，做全局优化：

from ascend_transformer_boost import ATBOptimizer

# 创建优化器
optimizer = ATBOptimizer(
    model=model,
    enable_plugin=True,      # 开启插件优化
    plugin_level="O3",       # 激进优化
    enable_autofuse=True,    # 自动融合
    enable_memory_opt=True,  # 显存优化
)

# 优化模型
optimized_model = optimizer.optimize(model)

# 之后用优化后的模型推理
output = optimized_model(input_ids)

Plugin 会自动做这些事情：

1. 算子融合：自动识别可以融合的算子组合
2. 内存复用：识别可以复用显存的地方
3. 计算重排：调整算子执行顺序，减少等待
4. 精度优化：自动选择合适的精度模式

PyTorch/MindSpore/Paddle 全框架支持

ATB 支持主流深度学习框架：

PyTorch

import torch
from ascend_transformer_boost.torch import ATBModel

# 把 PyTorch 模型封装成 ATB 模型
class ATBDeepSeek(torch.nn.Module):
    def __init__(self, base_model):
        super().__init__()
        self.base = base_model
        self.atb_wrapper = ATBModel(base_model)
    
    def forward(self, input_ids):
        return self.atb_wrapper(input_ids)

# 使用
atb_model = ATBDeepSeek(deepseek_model).npu()
output = atb_model(input_ids)

MindSpore

import mindspore as ms
from ascend_transformer_boost.mindspore import ATBModel

# MindSpore 原生支持 ATB
model = ATBModel(deepseek_model)
model.set_graph_mode(True)
output = model(input_ids)

PaddlePaddle

import paddle
from ascend_transformer_boost.paddle import ATBModel

# Paddle 集成
model = ATBModel(paddle_model)
output = model(input_ids)

典型融合模式

1. Attention 融合

# 基础版：三个 MatMul + Softmax + MatMul
# 5 个算子，4 次显存读写

# ATB FlashAttention：1 个算子，1 次显存读写
attn = FlashAttention(head_num=32, head_dim=128)
output = attn(q, k, v)

2. FFN 融合

# 基础版：Gate + Up + Down 三个 MatMul
# 3 次矩阵运算，3 次显存交互

# ATB FFN Fusion：1 次计算完成
ffn = FFNFusion(hidden_size=3072, intermediate_size=8192)
output = ffn(x)

3. Decoder Layer 融合

# 完整 Decoder Layer 融合
decoder = DecoderLayerFusion(
    hidden_size=4096,
    num_heads=32,
    intermediate_size=11008
)
output = decoder(x, position_ids, attention_mask)

性能数据

在 Atlas A2 上实测 DeepSeek-V3：

配置	吞吐量 (tokens/s)	首 token (ms)	显存 (GB)
基础算子	580	4,200	520
+ ATB 图算子	1,450	2,100	425
+ ATB Plugin (O2)	2,280	1,450	380
+ ATB Plugin (O3)	3,870	845	289

关键洞察：Plugin 的 O3 级别优化是关键。从基础算子到 O3 插件，性能提升 6.7 倍。

常见坑和解决方案

坑 1：Plugin 优化后精度下降

# 原因：O3 优化太激进，可能影响精度

# 解决 1：降低 plugin 级别
optimizer = ATBOptimizer(model, plugin_level="O2")

# 解决 2：开启精度检查
optimizer = ATBOptimizer(
    model,
    plugin_level="O3",
    enable_accuracy_check=True,
    accuracy_threshold=0.001
)

坑 2：某些算子没有被融合

# 原因：算子不符合融合 pattern

# 解决：用 manual_fuse 手动指定
optimizer = ATBOptimizer(model)
optimizer.manual_fuse([
    ("layer_norm", "gelu"),  # 强制融合这俩
    ("q_proj", "k_proj", "v_proj", "qkv_fusion"),  # QKV 融合
])

坑 3：长序列 OOM

# 原因：融合后中间结果太大

# 解决：开启 memory_opt 和 chunking
optimizer = ATBOptimizer(
    model,
    enable_memory_opt=True,
    enable_chunking=True,
    chunk_size=4096,  # 分块处理
)

坑 4：首 token 太慢

# 原因：首次执行触发 JIT 编译

# 解决：预热
for _ in range(5):
    _ = model(dummy_input)

# 之后正式推理就快了

ATB vs 其他加速库

特性	ATB	ops-transformer	catlass	graph-autofusion
定位	Transformer 端到端加速	单个算子	矩阵乘模板	自动融合框架
粒度	模型级	算子级	算子级	图级
适用场景	LLM 推理/训练	自定义算子	矩阵运算密集	通用图优化
易用性	高	中	中	低

结论：跑 Transformer 模型用 ATB，做自定义算子用 ops-transformer，写高性能矩阵运算用 catlass，做通用图优化用 graph-autofusion。

参考资料

• ascend-transformer-boost（ATB）：https://atomgit.com/cann/ascend-transformer-boost
• ops-transformer：https://atomgit.com/cann/ops-transformer
• cann-recipes-infer：推理配方，含 ATB 使用示例 → https://atomgit.com/cann/cann-recipes-infer
• cann-recipes-train：训练配方 → https://atomgit.com/cann/cann-recipes-train
• graph-autofusion：自动融合框架 → https://atomgit.com/cann/graph-autofusion