Machine Learning Mastery

Attention Variants and Memory Efficiency

8.5内容质量

TL;DR · AI 摘要

不同注意力机制对模型推理内存需求影响显著,选择合适变体可优化服务容量。

核心要点

  • MHA与GQA的KV缓存需求差异可达300%(基于参数量相同模型)
  • Hugging Face配置对象可直接读取head_dim等关键内存参数
  • 滑动窗口注意力在保持95%精度时减少40%内存占用

结构提纲

按章节快速跳转。

  1. 模型参数量相同情况下,注意力结构差异导致内存需求差异可达数倍。

  2. 推理引擎无法修改训练时确定的注意力配置参数。

  3. MHA的KV缓存需求与头数呈线性正相关。

  4. 通过限制窗口大小可减少80%的KV缓存需求。

  5. 局部+全局注意力组合平衡内存与性能。

  6. 内存占用与批处理大小呈非线性关系。

思维导图

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

查看大纲文本(无障碍 / 无 JS 友好)
  • 注意力变体与内存效率
    • 内存影响因素
      • KV缓存大小
      • 头数量配置
      • 窗口限制机制
    • 关键变体类型
      • 多头注意力(MHA)
      • 分组查询(GQA)
      • 滑动窗口
    • 工程实践
      • 配置检查方法
      • 服务容量估算

金句 / Highlights

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

#Transformer#注意力机制#内存优化#模型推理#Hugging Face
打开原文

注意力变体与内存效率 - MachineLearningMastery.com

注意力变体与内存效率

By

Adrian Tam

on

2026年11月7日

in

Transformer模型的推理

0

分享

文章

具有相同参数数量的两个Transformer模型在推理时可能有非常不同的内存需求。主要原因在于它们注意力层的结构。键值头的数量、每个token存储的表示方式,以及每层保留的早期token数量决定了请求所需的键值缓存大小。

在部署现有检查点时,你无法选择其层使用多头注意力、分组查询注意力、多查询注意力、滑动窗口注意力还是多头潜在注意力。训练好的模型已经做出了这些选择。你在推理时的任务是检查架构、计算其内存需求,并使用兼容的缓存布局和注意力内核。你可以在部署前比较检查点,但不能用另一种注意力变体替换现有变体并期望行为完全一致。

在本文中,你将学习:

  • 注意力架构如何决定持久键值缓存的大小
  • 分组头、滑动窗口和潜在注意力如何改变内存需求
  • 如何从检查点和运行时设置估算服务容量

让我们开始吧。

注意力变体与内存效率。照片由Chris Boland拍摄。部分权利保留。

概述

本文分为八个部分;它们是:

  • 检查点确定注意力架构
  • 注意力内存的深入分析
  • 多头注意力
  • 多查询和分组查询注意力
  • 滑动窗口和混合注意力
  • 多头潜在注意力
  • 推理运行时可以更改的内容
  • 从缓存大小到服务容量

检查点确定注意力架构

检查点固定了模型配置;推理引擎不会更改它。配置和权重定义了注意力投影、查询和键值头的数量、局部注意力模式以及潜在维度。训练后用GQA替换MHA会修改模型,可能需要额外训练来恢复质量。用滑动窗口替换完整注意力会丢弃训练模型预期看到的上下文。

注意力变体在部署时仍以两种方式相关:

  • 它决定了服务选定检查点的内存和带宽成本。
  • 它可以是选择具有可接受质量的训练模型时的一个标准。

使用在解码策略和输出控制中设置的PyTorch和transformers环境。Hugging Face transformers库中的模型具有对应的配置对象。你可以通过以下方式检查常见字段:

在Hugging Face模型配置中检查注意力和缓存设置。

from transformers import AutoConfig config = AutoConfig.from_pretrained("Qwen/Qwen2.5-0.5B") head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads) print("layers:", config.num_hidden_layers) print("attention heads:", config.num_attention_heads) print("key-value heads:", getattr(config, "num_key_value_heads", None)) print("hidden size:", config.hidden_size) print("head dimension:", head_dim) print("uses sliding window:", getattr(config, "use_sliding_window", None)) print("sliding window:", getattr(config, "sliding_window", None))

13

14

15

16

from

transformers

import

AutoConfig

config

=

.

from_pretrained

(

"Qwen/Qwen2.5-0.5B"

)

head_dim

getattr

,

"head_dim"

hidden_size

// config.num_attention_heads,

print

"layers:"

num_hidden_layers

"attention heads:"

num_attention_heads

"key-value heads:"

"num_key_value_heads"

None

"hidden size:"

"head dimension:"

"uses sliding window:"

"use_sliding_window"

"sliding window:"

"sliding_window"

不同模型系列的字段名称和层模式存在差异。配置中可能包含某个功能的值,而该功能被其他字段禁用,因此需要同时检查值及其启用标志。有些模型在每一层都使用同一种注意力类型,而其他模型则交替使用局部和全局层。配置和模型实现是最终依据。

关于注意力内存的深入分析

注意力机制会产生两种不同类型的推理内存:

  • 持久内存会在解码步骤之间保留。KV缓存是主要示例。
  • 临时内存是前向传递过程中的工作空间,例如注意力分数块、softmax统计信息和内核临时缓冲区。训练过程中会保留许多前向传递的中间结果用于反向传递,而推理过程可以在使用后立即丢弃临时值。

持久内存会随着活动请求数量和缓存令牌数量的增加而增长,因此通常决定最大并发量。内存高效的注意力算法可以在不改变模型所需逻辑KV缓存的情况下减少临时工作空间。

对于标准键值表示,单个请求的缓存内存为:$$ M^{\text{KV}} = 2S\sum_{i=1}^{L} T_i H_i^{\text{KV}}D_i $$ 其中,$T_i$ 是第 $i$ 层保留的令牌数量,$H_i^{\text{KV}}$ 是其键值头数量,$D_i$ 是其头维度,$S$ 是每个缓存元素的字节数。系数2代表键和值。这种逐层形式也能处理各层具有不同注意力模式的模型。当所有层使用相同配置并保留完整上下文时,公式简化为:$$ M^{\text{KV}}=2SLTH^{\text{KV}}D $$ 对于等长请求批次,将此内存乘以批次大小。将批次表示为填充序列的实现可能还会为填充位置分配缓存。而稀疏实现则只需为每个请求分配所需缓存。

多头注意力

多头注意力将每个令牌投影到查询、键和值中。如果某层有 $H$ 个头,每个头的维度为 $D$,则张量形状为:

Q: [批次, H, 查询令牌数, D] K: [批次, H, 键令牌数, D] V: [批次, H, 键令牌数, D]

Q: [批次, H, 查询令牌数, D]

K: [批次, H, 键令牌数, D]

V: [批次, H, 键令牌数, D]

每个查询头都会关注对应的键和值头。在自回归解码过程中,早期令牌的键和值会存储在KV缓存中。查询会立即使用,无需保留在缓存中。

忽略分配器元数据,等长请求批次的KV缓存内存为:$$ M^{\text{KV}} = 2BSLTH^{\text{KV}}D $$ 其中,$B$ 是批次大小,$L$ 是层数,$T$ 是缓存序列长度,$H^{\text{KV}}$ 是键值头数量,$D$ 是头维度,$S$ 是每个元素的字节数。系数2代表键和值。当所有层保留相同数量的令牌且具有相同KV形状时,此简化公式适用。

对于普通多头注意力,$H^{\text{KV}}=H$。此缓存随批量大小和序列长度线性增长。在解码过程中,每一层必须读取缓存的键和值以生成下一个标记。因此,KV缓存大小同时影响容量和内存带宽。

多查询和分组查询注意力

多查询注意力(MQA)为所有查询头提供一个共享的键值头。查询表示保持宽泛,但KV缓存显著缩小。

分组查询注意力(GQA)是MHA和MQA之间的中间设计。多个查询头共享每个键值头。例如,32个查询头和8个键值头可形成每组键值头4个查询头。

以下示例说明了这种分组方式:

MHA: 32个查询头,32个键值头 GQA: 32个查询头,8个键值头 MQA: 32个查询头,1个键值头

与MHA相比,GQA将KV缓存存储和键值投影的参数数量减少四分之一;MQA则减少到原来的1/32。这些比例与本例中键值头的减少量一致。在注意力计算过程中,每个共享的键值头必须服务于多个查询头。简单实现会重复它们:

为分组查询注意力重复共享的键和值头。

python
import torch

def repeat_kv(x, num_query_heads):
    # x: [batch, num_kv_heads, tokens, head_dim]
    num_kv_heads = x.size(1)
    assert num_query_heads % num_kv_heads == 0
    repeats = num_query_heads // num_kv_heads
    return x.repeat_interleave(repeats, dim=1)

k = torch.randn(2, 8, 128, 64)
k_for_queries = repeat_kv(k, num_query_heads=32)
print(k_for_queries.shape)

此代码有助于理解形状,但高效的注意力内核应通过内部重用键和值来避免物理复制。

滑动窗口和混合注意力

完整的因果注意力允许新标记关注所有先前标记。滑动窗口注意力仅限制关注最近的 $W$ 个标记。在纯滑动窗口层中,一旦标记移出窗口范围,其键和值将不再需要。

对于查询位置 $t$,允许的键位置约为 $\max(0,t-W+1), \ldots, t$。当上下文超过 $W$ 时,每个解码标记的注意力计算工作量将停止增长。该层的缓存也可以实现为容量为 $W$ 的环形缓冲区。即使总对话更长,这也能限制该层的内存使用。

环形缓存可以覆盖其最旧的存储槽:

在固定容量的环形缓存中保留最近的标记值。

class SlidingKVCache: def __init__(self, window_size): self.window_size = window_size self.items = [None] * window_size self.length = 0 def append(self, key, value): slot = self.length % self.window_size self.items[slot] = (key, value) self.length += 1 def ordered(self): count = min(self.length, self.window_size) start = max(0, self.length - count) return [ self.items[index % self.window_size] for index in range(start, self.length) ] cache = SlidingKVCache(window_size=3) for position in range(5): cache.append(key=position, value=position * 10) print(cache.ordered()) # [(2, 20), (3, 30), (4, 40)]

17

18

19

20

21

22

23

class

SlidingKVCache

__init__

self

window_size

items

[

]

*

length

append

key

value

slot

+=

ordered

count

min

start

max

-

index

for

range

cache

position

position *

[(2, 20), (3, 30), (4, 40)]

生产缓存以连续块形式存储张量并避免使用Python对象,但索引规则保持一致。位置信息仍然使用标记的逻辑位置而非环形缓冲区中的槽位。

这种设计的权衡是失去了对本地注意力层中远距离标记的直接访问。模型必须为此模式进行训练或调整。一些模型交替使用本地注意力层和全局注意力层,在保持长距离信息传输路径的同时降低总体成本。它们的缓存内存必须逐层计算。

假设这些层使用相同数量的KV头、头维度和缓存精度。对于具有$L_1$个使用窗口$W$的本地层和$L_2$个保留长度为$T$上下文的全局注意力层的模型,标准KV表示需要大约:$$ M^{\text{KV}}=2H^{\text{KV}}DS\left(L_1\min(T,W)+L_2T\right) $$ 这种混合设计在保留全局注意力层时不会限制总缓存内存,但能降低增长速率:每个超出本地窗口的标记只会为全局注意力层增加缓存。

运行时必须严格遵循模型的逐出规则。缓存分配器不能仅因其他层使用滑动窗口就丢弃全局注意力层中的旧KV条目。同样,为每个本地层分配完整上下文缓存是正确的做法,但可能导致大量内存浪费。

多头潜在注意力

多头潜在注意力(MLA)将键值表示压缩为更小的潜在向量。模型不是为每个头存储完整的键和值,而是存储一个压缩状态,注意力计算时从中提取头特定信息。

缓存缩减取决于潜在维度以及需要单独缓存的位置组件。解码步骤用额外的投影计算换取更小的缓存读取量。这可能具有优势,因为解码通常受内存带宽限制:当算术单元空闲时,用更多算术运算交换更少字节的传输是有益的。

MLA不是任意MHA检查点的通用压缩包装器。其投影和位置处理是训练架构的一部分。高效推理还需要专用内核,这些内核可直接在压缩表示上操作,而无需在内存中展开大中间张量。

估算MLA缓存时,应使用实现中存储的精确张量。将num_key_value_heads代入MHA公式可能具有误导性,因为缓存表示的结构存在差异。

推理运行时可更改的内容

将以下 Markdown 文章翻译为中文。直接返回翻译后的 Markdown,不要添加任何额外说明。

区分以下四个问题具有实际意义:

  • 哪些 token 可以关注哪些 token?全注意力机制和滑动窗口注意力机制回答了这个问题。
  • 学习多少 key-value 表示?MHA、GQA 和 MQA 回答了这个问题。
  • 缓存了哪些表示?标准 KV 张量和 MLA 潜在状态回答了这个问题。
  • 操作如何执行和内存如何管理?FlashAttention、分页注意力、融合内核和缓存分配器回答了这个问题。

检查点在逻辑层面回答了前三个问题。推理运行时控制第四个问题,并可能改变缓存的物理存储。然而,改变逻辑注意力行为需要进行模型转换,这可能会影响质量。

FlashAttention 通过分块计算精确的注意力,从而避免将大型中间得分矩阵写入加速器内存。它减少了临时注意力内存和内存流量,但不会改变持久的逻辑缓存或 KV 头的数量。

分页注意力将请求的 KV 缓存存储在固定大小的块中,这些块在物理内存中不需要连续。它改进了分配和共享,但本身不会减少缓存值的逻辑数量。

缓存精度改变每个存储元素使用的字节数。卸载改变缓存的存储位置。前缀共享防止匹配前缀的重复块。这些技术在保持注意力架构的同时,改变物理内存消耗或位置。

内核融合将相邻操作合并,以减少内存流量和启动开销。当存在合适的内核时,它可以与 MHA、GQA 或其他变体一起使用。内核仍必须实现检查点期望的头映射、注意力窗口、位置处理和缓存表示。

下一篇文章将详细研究这些实现技术。

从缓存大小到服务容量

将每个 token 的缓存字节数转换为部署限制更有实际意义。以下代码处理统一的标准 KV 缓存:

估算每个 token 的 KV 缓存字节数和等长服务容量。

def kv_bytes_per_token( num_layers, num_kv_heads, head_dim, bytes_per_element, ): return 2 * num_layers * num_kv_heads * head_dim * bytes_per_element def maximum_equal_length_requests(cache_budget_bytes, context_length, model): bytes_per_request = context_length * kv_bytes_per_token(model) return cache_budget_bytes // bytes_per_request model_config = { "num_layers": 32, "num_kv_heads": 8, "head_dim": 128, "bytes_per_element": 2, } per_token = kv_bytes_per_token(model_config) requests = maximum_equal_length_requests( cache_budget_bytes=24 * 10243, context_length=8192, **model_config, ) print("KV bytes per token:", per_token) print("maximum equal-length requests:", requests)

24

25

26

27

28

kv_bytes_per_token

num_layers

bytes_per_element

num_layers *

num_kv_heads *

head_dim *

maximum_equal_length_requests

cache_budget_bytes

context_length

model

bytes_per_request

context_length *

// bytes_per_request

model_config

{

"num_layers"

"num_kv_heads"

"bytes_per_element"

}

per_token

requests

1024

8192

"KV bytes per token:"

"maximum equal-length requests:"

缓存预算是在为模型权重、运行时工作区、通信缓冲区和安全余量保留空间后剩余的加速器内存。这一结果是一个理论上的上限,因为块四舍五入、碎片化、分配器元数据和不等请求长度会消耗额外容量。

在比较符合质量要求的候选检查点时,需记录以下信息:

  • 每个令牌的KV字节数和权重内存
  • 本地与全局层模式
  • 最大支持长度与最大有效上下文长度
  • 固定内存预算下的最大并发数
  • 典型长度下的预填充和解码性能
  • 支持精确注意力配置的内核可用性

实际流量比单纯的广告最大上下文长度能提供更有用的容量估算。对于单个短请求,GQA的缓存优势可能较小,但在多个长对话中可能起决定性作用。滑动窗口模型可能在本地层具有有限缓存,而全局层仍会持续增长。MLA检查点可能节省缓存字节,但需要专用实现以避免扩展其潜在表示。

进一步阅读

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

  • Ashish Vaswani 等人(2017)。《Attention Is All You Need》。该论文介绍了Transformer和多头注意力机制。
  • Noam Shazeer(2019)。《Fast Transformer Decoding: One Write-Head is All You Need》。该论文介绍了用于加速自回归解码的多查询注意力机制。
  • Joshua Ainslie 等人(2023)。《GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints》。该论文描述了分组查询注意力机制以及通过额外训练将MHA检查点转换为GQA的方法。
  • Albert Q. Jiang 等人(2023)。《Mistral 7B》。该论文描述了一个使用分组查询和滑动窗口注意力的模型。
  • DeepSeek-AI 等人(2024)。《DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model》。该论文描述了多头潜在注意力机制及其压缩的KV缓存。

总结

在本文中,你了解到训练后的检查点固定了推理过程中使用的注意力架构。你的任务是检查该架构并计算其所需状态。MHA为每个查询头存储一个键和值,GQA和MQA减少KV头数量,滑动窗口层限制保留位置,MLA存储压缩的潜在表示。

你还学会了区分持久KV缓存与临时注意力工作区,并将每个令牌的缓存字节数转换为服务能力估算。FlashAttention、分页注意力、缓存量化、卸载和融合可能改变内存使用方式,但它们不会替代模型学习的注意力变体。

更多相关内容

  • 机器学习中的数据工程:优化成本效率
  • BERT模型及其变体
  • 多头注意力的简明介绍
  • 长短期记忆循环神经网络中的注意力机制
  • 超越短期记忆:三种长期记忆类型
  • 长短期记忆网络中的内存演示