Machine Learning Mastery

Fast Attention Kernels and Operator Fusion

8.5内容质量

TL;DR · AI 摘要

操作融合与快速注意力内核可提升Transformer推理性能,vLLM和CUDA图是关键实现手段。

核心要点

  • 操作融合可减少30%以上的内核启动次数和内存流量
  • FlashAttention内核通过分块计算降低内存访问延迟
  • CUDA图编译能减少重复推理步骤的50%启动开销

结构提纲

按章节快速跳转。

  1. 介绍Transformer优化的四个关键技术方向及环境准备要求

  2. 通过合并线性投影和激活函数减少内存访问次数

  3. 分块计算机制优化缓存利用率和内存带宽使用

  4. 基于内存映射的键值缓存管理方案

  5. ›CUDA图融合

    torch.compile实现的静态编译优化技术

思维导图

用一张图看清主题之间的关系。

查看大纲文本(无障碍 / 无 JS 友好)
  • Transformer推理优化
    • 操作融合
      • 减少内存拷贝
      • 合并计算步骤
    • 快速内核
      • FlashAttention
      • 分页机制
    • 编译优化
      • CUDA图
      • torch.compile

金句 / Highlights

值得收藏与分享的关键句。

#Transformer#CUDA#模型优化#vLLM
打开原文

快速注意力内核与操作符融合 - MachineLearningMastery.com

快速注意力内核与操作符融合

By

Adrian Tam

on

2026年11月7日

in

Transformer模型的推理

0

Share

Post

Transformer层由熟悉的运算构建:线性投影、注意力、归一化、激活函数和残差连接。直接实现可能会为每个运算启动单独的加速器内核,并将每个中间张量写入设备内存。数学上是正确的,但执行时可能花费更多时间在值的移动和内核启动上,而不是执行有用的算术运算。

快速注意力内核和操作符融合重新组织了这些工作。它们将中间值保持在算术单元附近,合并运算,并重用编译后的执行计划。这些优化通常不会改变模型权重和数学函数,尽管由于运算顺序和精度的不同,可能会出现微小的数值差异。

在本文中,你将学习到:

  • 操作符融合如何减少内核启动和中间内存流量
  • 快速注意力和分页注意力内核如何改变执行和缓存访问
  • CUDA图和编译如何影响重复的推理步骤

让我们开始吧。

快速注意力内核与操作符融合。照片由Chris Boland拍摄。部分权利保留。

概述

本文分为四个部分:

  • 操作符融合
  • FlashAttention风格内核
  • 分页注意力内核
  • 与torch.compile()的融合和CUDA图

注意:从本文开始,你将运行依赖于vLLM的代码。你可以通过python -m pip install vllm安装vLLM。此环境应具有与你的驱动程序匹配的CUDA启用PyTorch构建,以便torch.compile()可以使用CUDA图。另外请注意,运行代码可能会下载模型检查点和其他数据。请确保有足够的磁盘空间。

操作符融合

许多仅解码器模型使用的SwiGLU块提供了一个例子:$$ \mathbf{y} = \mathbf{W}_{\text{down}}\big(\operatorname{SiLU}(\mathbf{W}_{\text{gate}}\mathbf{x}) \odot \mathbf{W}_{\text{up}}\mathbf{x}\big) $$ 直接实现会为投影启动矩阵乘法,为SiLU启动一个内核,为逐元素乘法启动另一个内核,最后再启动一个矩阵乘法。每个边界都可能将中间张量写入高带宽内存并读取回来。

运行一个小的门控MLP作为可以融合的操作示例。

import torch import torch.nn as nn import torch.nn.functional as F class GatedMLP(nn.Module): def __init__(self, hidden_size, intermediate_size): super().__init__() self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False) self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False) self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False) def forward(self, x): gate = F.silu(self.gate_proj(x)) up = self.up_proj(x) return self.down_proj(gate * up) model = GatedMLP(hidden_size=16, intermediate_size=32).eval() print(model(torch.randn(2, 4, 16)).shape)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

import

torch

.

nn

as

functional

F

class

GatedMLP

(

Module

)

:

def

__init__

self

,

hidden_size

intermediate_size

super

gate_proj

=

Linear

bias

False

up_proj

down_proj

forward

x

gate

silu

up

return

gate *

model

32

eval

print

randn

shape

该代码清晰地表达了模型,通常应作为参考实现保留。它包含三次矩阵乘法、一次逐点SiLU激活函数和一次逐点乘法。优化的后端可能将SiLU与乘法融合、合并投影操作,或选择避免额外转置和内核启动的布局。

当中间内存流量和启动开销显著时,融合操作可以节省时间。但如果大矩阵乘法已经主导执行,或融合内核使用了低效的形状,效果会减弱。内核选择是经验性的:对完整工作负载进行性能分析。

其他常见的Transformer融合机会包括:

  • 添加残差连接并应用RMSNorm或LayerNorm
  • 应用偏置、激活函数和逐元素乘法
  • 将旋转位置嵌入应用到查询和键
  • 在转换键和值张量时更新KV缓存
  • 将反量化与矩阵乘法结合

例如,融合的残差和RMS归一化可以概念性地执行以下操作:

计算带有RMS归一化的残差更新。

python
import torch

def residual_rms_norm(x, residual, weight, eps=1e-6):
    x = x + residual
    variance = x.float().pow(2).mean(dim=-1, keepdim=True)
    normalized = x * torch.rsqrt(variance + eps).to(x.dtype)
    return normalized * weight, x

normalized, updated_residual = residual_rms_norm(
    torch.randn(2, 4, 16),
    torch.randn(2, 4, 16),
    torch.ones(16)
)

print(normalized.shape, updated_residual.shape)

residual_rms_norm residual weight eps 1e - + variance float pow mean dim keepdim True normalized x * rsqrt to dtype normalized * updated_residual ones

该函数同时返回归一化值和更新后的残差。融合内核可以一次性读取每个输入,执行归约和缩放操作,并写入两个所需输出。单独的PyTorch操作可能会产生更多的中间内存流量。

融合操作存在边界限制。布局不兼容、需要同步或具有非常大中间状态的操作可能无法高效合并。一个巨大的融合内核也可能增加寄存器压力,降低占用率,甚至比多个精心调优的内核更慢。

FlashAttention风格的内核

带有加法注意力掩码的普通注意力可以表示为: $$ \operatorname{Attention}(\mathbf{Q},\mathbf{K},\mathbf{V}) = \operatorname{softmax}\big(\frac{\mathbf{Q}\mathbf{K}^\top}{\sqrt{d}} + \mathbf{M}\big)\mathbf{V} $$

简单实现会显式生成注意力得分矩阵$\mathbf{Q}\mathbf{K}^\top$。对于序列长度$T$,每个头的矩阵包含$T^2$个元素。在GPU上,计算该矩阵、将其写入全局内存并在softmax中读取回内存,会消耗大量流式多处理器(SMs)与设备内存(通常是高带宽内存HBM)之间的带宽。这种内存流量在长预填充阶段可能成为瓶颈。

FlashAttention以分块方式处理查询、键和值。对每个分块,它计算得分块、更新softmax统计信息,并使用片上内存累积对应输出。它避免将完整的得分矩阵存储到全局内存中。PyTorch通过scaled_dot_product_attention()暴露了优化后的注意力实现:

在查询、键和值张量上调用PyTorch缩放点积注意力。

import torch import torch.nn.functional as F from torch.nn.attention import SDPBackend, sdpa_kernel

if not torch.cuda.is_available(): raise RuntimeError("This example requires a CUDA GPU") device = "cuda" dtype = torch.float16

q = torch.randn(2, 16, 512, 64, device=device, dtype=dtype) k = torch.randn(2, 16, 512, 64, device=device, dtype=dtype) v = torch.randn(2, 16, 512, 64, device=device, dtype=dtype)

with torch.no_grad(), sdpa_kernel( [SDPBackend.FLASH_ATTENTION, SDPBackend.CUDNN_ATTENTION], set_priority=True ): output = F.scaled_dot_product_attention(q, k, v, is_causal=True) print(output.shape)

如果没有使用 sdpa_kernel() 上下文管理器,PyTorch 会根据设备、数据类型、张量布局、头维度和掩码等因素自动选择后端。该示例明确优先使用 FlashAttention,其次是 cuDNN attention。硬编码指定这些后端可能导致代码在输入或硬件不支持时出现故障。

FlashAttention 对预填充阶段特别有价值,因为许多查询标记可以同时处理。解码阶段每个请求仅有一个或几个新查询。虽然仍然能从专用内核中受益,但读取不断增长的键值缓存(KV cache)通常成为更大的性能瓶颈。

分页注意力内核

请求的 KV 缓存每次增长一个标记,最终长度不可预测。要求每个请求分配连续内存会导致预留但未使用的空间,并使缓存移动或调整变得昂贵。

分页 KV 缓存将存储划分为固定大小的块,并将缓存的逻辑表示与物理表示分离。逻辑序列通过块表进行表示:

逻辑块: 物理块:

29

注意力内核在读取键和值时会遵循该表。即使物理内存不连续,逻辑标记顺序仍保持连续。块可以按需分配,请求结束后返回到内存池,并在序列有共同前缀时共享。

因此,分页注意力结合了内存管理设计与专用内核。内核不能假设 K[t+1] 与 K[t] 相邻;必须通过块表将逻辑位置转换为物理位置。分页不会减少序列中逻辑 KV 元素的数量,但能减少碎片化和预留容量。

PyTorch 可以通过 FlexAttention 和 torch.compile() 实现分页注意力。在集成服务示例中,vLLM 以块形式分配 KV 缓存,并向其注意力后端提供块表。以下示例明确选择 16 个标记的缓存块大小:

使用 vLLM 和选定的 KV 缓存块大小生成文本。

from vllm import LLM, SamplingParams attention_backend = "TRITON_ATTN" # vLLM 将此解码器模型的 KV 缓存存储在 16 个标记块中 llm = LLM( model="Qwen/Qwen2.5-1.5B-Instruct", dtype="float16", block_size=16, attention_backend=attention_backend, ) print("Attention backend:", attention_backend) # 设置采样参数 sampling_params = SamplingParams( temperature=0.7, top_p=0.95, max_tokens=64, ) # 发起请求 prompts = [ "Q: 法国的首都是哪里?\nA:", "Q: 《傲慢与偏见》的作者是谁?\nA:", ] outputs = llm.generate(prompts, sampling_params) for output in outputs: print(f"Prompt: {output.prompt!r}") print(f"Output: {output.outputs[0].text}\n")

21

22

23

24

25

26

27

28

30

31

vllm

LLM

SamplingParams

attention_backend

"TRITON_ATTN"

vLLM 将此解码器模型的 KV 缓存存储在 16 个标记块中。

"Qwen/Qwen2.5-1.5B-Instruct"

"float16"

block_size

"Attention backend:"

设置采样参数

sampling_params

temperature

0.7

top_p

0.95

max_tokens

发起请求

prompts

"Q: 法国的首都是哪里?\nA:"

"Q: 《傲慢与偏见》的作者是谁?\nA:"

outputs

generate

for

"Prompt: {output.prompt!r}"

"Output: {output.outputs[0].text}\n"

此示例使用了分页 KV 缓存管理,但 block_size 单独并不决定计算后端。attention_backend 参数明确请求 TRITON_ATTN,其前向传播路径在分页管理的 KV 缓存上实现了分页注意力。初始化时,vLLM 会验证后端与模型和硬件的兼容性,若不兼容则会报错。若初始化成功,打印的值将确认当前使用了分页注意力后端。

与 torch.compile 的融合和 CUDA 图

手动编写的 CUDA 或 Triton 内核可以提供控制权,但需要专业工作。PyTorch 可以通过 TorchDynamo 捕获操作序列,并通过 TorchInductor(torch.compile() 的默认后端)编译捕获的图。TorchInductor 会执行图重写、缓冲区复用和操作符融合等优化。在 GPU 上,它可以为兼容的逐点或归约操作生成单个 Triton 内核,而 eager 模式下的 PyTorch 会分别启动这些操作。

因此,torch.compile() 确实会执行融合操作,但并非所有操作都会被融合。融合取决于操作类型、张量布局、形状、设备和编译器后端。图中断也会限制编译器优化的区域。Python 侧的数据依赖控制流、不支持的操作以及从张量到 Python 标量的转换都可能导致一个模型被分割成多个编译后的图。

以下示例编译了前面使用的 GatedMLP。为使脚本独立运行,再次包含类定义。Inductor 后端启用了编译器优化,包括融合操作。reduce-overhead 模式要求 TorchInductor 在捕获的图符合条件时使用 CUDA 图:

比较 GatedMLP 的编译版本和 eager 模式的输出。

/think

import torch import torch.nn as nn import torch.nn.functional as F

class GatedMLP(nn.Module): def __init__(self, hidden_size, intermediate_size): super().__init__() self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False) self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False) self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False)

def forward(self, x): gate = F.silu(self.gate_proj(x)) up = self.up_proj(x) return self.down_proj(gate * up)

if not torch.cuda.is_available(): raise RuntimeError("此示例需要CUDA GPU")

model = GatedMLP( hidden_size=1024, intermediate_size=4096, ).eval().to(device="cuda", dtype=torch.float16)

x = torch.randn(1, 128, 1024, device="cuda", dtype=torch.float16)

compiled_model = torch.compile( model, backend="inductor", mode="reduce-overhead", )

with torch.inference_mode(): expected = model(x)

首次调用可能进行编译、预热并捕获符合条件的CUDA工作

for _ in range(3): actual = compiled_model(x) torch.cuda.synchronize() torch.testing.assert_close(actual, expected, rtol=1e-2, atol=1e-2)

print("compiled output matches eager output:", tuple(actual.shape))

33

34

35

36

37

38

39

40

41

42

43

44

1024

4096

128

compiled_model

compile

backend

"inductor"

mode

"reduce-overhead"

inference_mode

expected

首次调用可能进行编译、预热并捕获符合条件的CUDA工作

_

range

actual

synchronize

testing

assert_close

rtol

atol

"compiled output matches eager output:"

tuple

该代码使用torch.inference_mode()上下文管理器来禁用梯度计算以及视图跟踪和版本计数器更新。它比torch.no_grad()更严格。

融合和CUDA图移除了不同类型的开销。融合将兼容操作合并为更少的内核,减少中间内存流量和启动次数。CUDA图记录剩余的GPU操作序列并以一次CPU提交重放,减少Python、C++、驱动和内核启动开销。CUDA图不会创建额外的操作融合;它们补充了TorchInductor生成的融合内核。

CUDA图重放需要稳定的内存地址和兼容的形状。它对重复的小批量工作负载(如解码)最有用。当请求持续改变形状或使用数据依赖的控制流时,适用性较低。reduce-overhead模式不是保证:PyTorch仅对符合条件的CUDA图使用CUDA图,并可能通过保留重放的工作区分配消耗更多内存。

在Python环境中运行编译块之前,设置TORCH_LOGS=perf_hints以调查性能。PyTorch将记录有关CUDA图资格和其他编译器选择的提示。

使用TORCH_LOGS=output_code重新运行相同代码块以检查TorchInductor生成的输出。这些环境变量必须在启动Python之前设置;在导入PyTorch之后设置可能无法启用请求的日志。

生成的代码可能包含列出多个融合操作的Triton内核名称。还可以使用torch.profiler比较eager和编译执行。更少的内核提供了融合的证据,但最终的测试是端到端性能。

Eager执行和编译执行可能会因编译过程改变浮点运算顺序而产生略微不同的结果。应使用与数据类型(dtype)相适应的容差范围来验证结果。动态张量形状可能触发重新编译并意外降低融合效果。因此,应检查性能分析器轨迹、数值输出和应用级性能,而不仅仅是确认编译已完成。

进一步阅读

以下是一些可能对你有帮助的资源:

  • Tri Dao等(2022)."FlashAttention:具有IO感知的快速且内存高效的精确注意力机制". 该论文介绍了用于精确注意力的IO感知分块算法.
  • Tri Dao(2023)."FlashAttention-2". 该论文改进了注意力内核的工作划分和并行性.
  • Woosuk Kwon等(2023)."使用PagedAttention进行大语言模型服务的高效内存管理". 该论文描述了分页KV缓存管理及vLLM服务系统.
  • PyTorch博客."推理用FlexAttention". 该文章演示了使用FlexAttention和torch.compile构建的原生PyTorch分页注意力实现.
  • vLLM文档."注意力后端功能支持". 该页面解释了自动后端选择及各硬件平台可用的后端.
  • PyTorch文档."缩放点积注意力". 该页面记录了统一的PyTorch注意力API及其后端行为.
  • PyTorch文档."torch.compile". 该页面记录了编译模式,包括reduce-overhead模式及其对CUDA图的使用.
  • PyTorch博客."为什么PyTorch编译如此快速?内核融合". 该文章展示了TorchInductor如何将兼容操作合并到生成的Triton内核中.
  • PyTorch文档."CUDA语义". 该章节解释了CUDA图的捕获、重放、内存需求和约束.

总结

在本文中,你了解到快速内核通过减少内存流量、中间张量和启动开销来提升推理性能。FlashAttention通过分块精确注意力机制,使完整的得分矩阵无需存储在高带宽内存中。分页注意力通过块表实现KV缓存内存的灵活分配。torch.compile()函数使用TorchInductor优化捕获的图并融合兼容操作,而CUDA图通过减少剩余内核重放的启动开销来补充融合效果.

这些技术依赖于形状、布局、数据类型和硬件支持.

更多相关内容

  • 理解RAG III:融合检索与重排序
  • 使用LoRA进行快速且经济的微调LLM推理...
  • 如何通过深度学习快速获得良好结果...
  • R语言快速入门(面向开发者)
  • 多头注意力的温和介绍...
  • 注意力变体与内存效率