Fast Transformer Decoding: One Write-Head is All You Need
- 发表版本
- 正式发表信息尚未核实
- arXiv 首次提交
- arXiv:1911.02150
引用此论文 · BibTeX
引用信息对应所链接的论文版本,作者为原论文作者。
@misc{transformersmqa2019,
title = {{Fast Transformer Decoding: One Write-Head is All You Need}},
author = {Noam Shazeer},
year = {2019},
eprint = {1911.02150},
archivePrefix = {arXiv},
url = {https://arxiv.org/abs/1911.02150}
}
共享经济大行其道,看来在注意力机制中也可以这样玩。
这篇论文的作者是 Noam Shazeer,是 「Attention is all you need」 的作者群。
定义问题
作者在提出一般的注意力机制后,发现在解码的过程中,由于使用自回归的方式输出,每一个位置都会计算所有的键值对,会导致大量的重复计算。
这样操作非常的低效,作者认为这是一个可以改进的地方。
回顾注意力机制
想要知道作者怎么改进这个问题,那我们就必须从原本的注意力机制开始看起。
Dot-Product Att
首先介绍处理单个查询向量(query)和一组键值对(keys-values)的关系。
def DotProductAttention(q, K, V):
"""
Dot-Product Attention on one query.
Args:
q: 一个形状为 [k] 的向量(query,查询向量)
K: 形状为 [m, k] 的矩阵(keys,键向量集合)
V: 形状为 [m, v] 的矩阵(values,值向量集合)
Returns:
y: 形状为 [v] 的向量(输出结果向量)
"""
# 计算查询向量 q 和键矩阵 K 的点积,产生 logits,形状为 [m]
logits = tf.einsum("k,mk->m", q, K)
# 对 logits 使用 softmax,得到每个键的权重,形状为 [m]
weights = tf.nn.softmax(logits)
# 使用权重对值矩阵 V 进行加权求和,输出向量 y 形状为 [v]
y = tf.einsum("m,mv->v", weights, V)
return y
这是经典的点积注意力机制。
它将查询与键进行点积以计算相似性,并根据这些相似性对值进行加权,最终生成输出向量。
Multi-head Att
再来是多头注意力机制,这是将多个点积注意力机制组合在一起,以提高模型的表现。
在下列函数中,参数意义表示:
- :查询向量的维度
- :键值对的数量
- :注意力头的数量
- :查询和键的线性投影维度
- :值的线性投影维度
import tensorflow as tf
def MultiheadAttention(x, M, P_q, P_k, P_v, P_o):
"""
Multi-head Attention on one query.
Args:
x: 一个形状为 [d] 的向量,表示查询向量
M: 一个形状为 [m, d] 的矩阵,表示键和值的矩阵
P_q: 一个形状为 [h, d, k] 的张量,表示查询的线性投影矩阵
P_k: 一个形状为 [h, d, k] 的张量,表示键的线性投影矩阵
P_v: 一个形状为 [h, d, v] 的张量,表示值的线性投影矩阵
P_o: 一个形状为 [h, d, v] 的张量,表示输出的线性投影矩阵
Returns:
y: 一个形状为 [d] 的向量,最终的输出结果
"""
# 查询向量 x 的线性投影,形状为 [h, k]
q = tf.einsum("d, hdk->hk", x, P_q)
# 键和值矩阵 M 的线性投影
# 键矩阵 K 的形状为 [h, m, k],值矩阵 V 的形状为 [h, m, v]
K = tf.einsum("md, hdk->hmk", M, P_k)
V = tf.einsum("md, hdv->hmv", M, P_v)
# 计算查询与键的点积(logits),形状为 [h, m]
logits = tf.einsum("hk, hmk->hm", q, K)
# 使用 softmax 计算注意力权重,形状为 [h, m]
weights = tf.nn.softmax(logits)
# 使用权重对值向量进行加权求和,形状为 [h, v]
o = tf.einsum("hm, hmv->hv", weights, V)
# 将多头输出进行线性投影并合并,最终输出向量形状为 [d]
y = tf.einsum("hv, hdv->d", o, P_o)
return y
Multi-head Att (Batched)
接着我们扩展一下。
在一般训练中,我们会使用批量训练,这时候我们就需要对上面的函数进行修改。
import tensorflow as tf
def MultiheadAttentionBatched(X, M, mask, P_q, P_k, P_v, P_o):
"""
Multi-head Attention for batched inputs.
Args:
X: 一个形状为 [b, n, d] 的张量,表示查询向量,批量大小为 b,序列长度为 n,向量维度为 d
M: 一个形状为 [b, m, d] 的张量,表示键和值矩阵,m 是键和值的数量
mask: 一个形状为 [b, h, n, m] 的张量,用于遮罩不合法的注意力位置
P_q: 一个形状为 [h, d, k] 的张量,表示查询的线性投影矩阵
P_k: 一个形状为 [h, d, k] 的张量,表示键的线性投影矩阵
P_v: 一个形状为 [h, d, v] 的张量,表示值的线性投影矩阵
P_o: 一个形状为 [h, d, v] 的张量,表示输出的线性投影矩阵
Returns:
Y: 一个形状为 [b, n, d] 的张量,最终的输出结果
"""
# 查询向量 X 的线性投影,形状为 [b, h, n, k]
Q = tf.einsum("bnd, hdk->bhnk", X, P_q)
# 键和值矩阵 M 的线性投影,键 K 的形状为 [b, h, m, k],值 V 的形状为 [b, h, m, v]
K = tf.einsum("bmd, hdk->bhmk", M, P_k)
V = tf.einsum("bmd, hdv->bhmv", M, P_v)
# 计算查询与键的点积(logits),形状为 [b, h, n, m]
logits = tf.einsum("bhnk, bhmk->bhnm", Q, K)
# 将 mask 应用于 logits 并使用 softmax 计算注意力权重,形状为 [b, h, n, m]
weights = tf.nn.softmax(logits + mask)
# 使用权重对值向量进行加权求和,形状为 [b, h, n, v]
O = tf.einsum("bhnm, bhmv->bhnv", weights, V)
# 将多头输出进行线性投影并合并,最终输出向量形状为 [b, n, d]
Y = tf.einsum("bhnv, hdv->bnd", O, P_o)
return Y
在这里,作者对计算与内存访问进行了简化假设:
- :假设键和值的数量 与查询的序列长度 相等。
- :根据 Transformer 原始论文的建议,查询和键的维度 等于值的维度 ,并且它们与特征维度 成正比,比例因子为头的数量 。
- :假设序列长度 小于或等于特征维度 。
根据这些假设,计算的总数量是 ,其中 是批量大小, 是序列长度, 是特征维度。这是由于每个 tf.einsum 操作的复杂度为 。
内存访问大小的部分,所有张量的总内存需求为 :
- 第一项 来自于输入 、键和值矩阵 、查询 、键 、值 、输出 和最终的输出 。
- 第二项 来自于 logits 和权重。
- 第三项 来自于投影张量 、、 和 。
内存访问与计算之比为:
这个比值越低,对现代 GPU/TPU 硬件的性能越好,因为这类硬件的计算能力远高于内存带宽。
Multi-head Att (Incremental)
除了一般的多头注意力机制,另外一种是基于自回归的增量注意力机制。
import tensorflow as tf
def MultiheadSelfAttentionIncremental(x, prev_K, prev_V, P_q, P_k, P_v, P_o):
"""
Multi-head Self-Attention for one step in incremental generation.
Args:
x: 一个形状为 [b, d] 的张量,表示当前步骤的查询向量
prev_K: 一个形状为 [b, h, m, k] 的张量,表示之前步骤的键矩阵
prev_V: 一个形状为 [b, h, m, v] 的张量,表示之前步骤的值矩阵
P_q: 一个形状为 [h, d, k] 的张量,表示查询向量的线性投影矩阵
P_k: 一个形状为 [h, d, k] 的张量,表示键的线性投影矩阵
P_v: 一个形状为 [h, d, v] 的张量,表示值的线性投影矩阵
P_o: 一个形状为 [h, d, v] 的张量,表示输出的线性投影矩阵
Returns:
y: 一个形状为 [b, d] 的张量,当前步骤的输出结果
new_K: 一个形状为 [b, h, m+1, k] 的张量,更新后的键矩阵
new_V: 一个形状为 [b, h, m+1, v] 的张量,更新后的值矩阵
"""
# 计算查询向量 x 的线性投影,形状为 [b, h, k]
q = tf.einsum("bd, hdk->bhk", x, P_q)
# 更新键矩阵,将当前步骤的新键向量与之前的键矩阵连接,形状为 [b, h, m+1, k]
new_K = tf.concat(
[prev_K, tf.expand_dims(tf.einsum("bd, hdk->bhk", x, P_k), axis=2)],
axis=2
)
# 更新值矩阵,将当前步骤的新值向量与之前的值矩阵连接,形状为 [b, h, m+1, v]
new_V = tf.concat(
[prev_V, tf.expand_dims(tf.einsum("bd, hdv->bhv", x, P_v), axis=2)],
axis=2
)
# 计算查询与键的点积(logits),形状为 [b, h, m+1]
logits = tf.einsum("bhk, bhmk->bhm", q, new_K)
# 使用 softmax 计算注意力权重,形状为 [b, h, m+1]
weights = tf.nn.softmax(logits)
# 使用权重对值向量进行加权求和,形状为 [b, h, v]
o = tf.einsum("bhm, bhmv->bhv", weights, new_V)
# 将多头输出进行线性投影并合并,最终输出向量形状为 [b, d]
y = tf.einsum("bhv, hdv->bd", o, P_o)
return y, new_K, new_V
作者沿用了之前的简化假设,并对增量推论进行了性能评估。
在整个推论过程中,运算量的总数为 ,其中 是批量大小, 是序列长度, 是特征维度。
内存访问的总量为 :
- 第一项 来自于每一步需要重新加载键 和值 的内存操作,这些张量的大小随着序列长度 增加而增加。
- 第二项 来自于查询、键和值的线性投影矩阵 。
内存访问与计算之比率为:
当 或 时,这个比率接近 1,说明内存带宽成为了现代计算硬件中的主要瓶颈。
比较简单的优化策略是增加批量大小,这样可以轻松减少内存访问与计算的比率。
另外一种是减少 比例,这比较困难,因为涉及到每一步重新加载键和值张量。优化方法包括限制序列长度 ,或者只对局部范围进行注意力计算,压缩需要处理的记忆位置数量。
解决问题
为了减少键和值张量的大小,作者提出的具体方法是去掉 和 的「头」(heads)维度,但保留查询中的「头」维度,从而减少内存负担并提高效率。
Multi-Query Attention
多查询注意力(Multi-Query Attention)是多头注意力(Multi-Head Attention)的一种变体。
在传统多头注意力中,不同的「头」会拥有独立的查询(queries)、键(keys)、值(values)和输出,但多查询注意力则简化了这一结构:不同的头共享一组键和值,仅保留查询的多头结构。这样可以减少内存的负担并提高推论速度。
def MultiQueryAttentionBatched(X, M, mask, P_q, P_k, P_v, P_o):
"""
Multi-Query Attention for batched inputs.
Args:
X: 一个形状为 [b, n, d] 的张量,表示查询向量
M: 一个形状为 [b, m, d] 的张量,表示键和值的矩阵
mask: 一个形状为 [b, h, n, m] 的张量,用于遮蔽无效的位置
P_q: 一个形状为 [h, d, k] 的张量,表示查询向量的线性投影
P_k: 一个形状为 [d, k] 的张量,表示键的线性投影
P_v: 一个形状为 [d, v] 的张量,表示值的线性投影
P_o: 一个形状为 [h, d, v] 的张量,表示输出向量的线性投影
Returns:
Y: 一个形状为 [b, n, d] 的张量,最终的输出结果
"""
# 查询向量 X 的线性投影,形状为 [b, h, n, k]
Q = tf.einsum("bnd, hdk->bhnk", X, P_q)
# 键和值矩阵 M 的线性投影,键 K 形状为 [b, m, k],值 V 形状为 [b, m, v]
K = tf.einsum("bmd, dk->bmk", M, P_k)
V = tf.einsum("bmd, dv->bmv", M, P_v)
# 计算查询与键的点积,形状为 [b, h, n, m]
logits = tf.einsum("bhnk, bmk->bhnm", Q, K)
# 应用 softmax 计算注意力权重,并考虑遮蔽
weights = tf.nn.softmax(logits + mask)
# 使用注意力权重对值进行加权求和,形状为 [b, h, n, v]
O = tf.einsum("bhnm, bmv->bhnv", weights, V)
# 最后的线性投影与合并,形状为 [b, n, d]
Y = tf.einsum("bhnv, hdv->bnd", O, P_o)
return Y
作者也提供了增量多查询自注意力(Incremental Multi-Query Self-Attention)的实现代码:
def MultiQuerySelfAttentionIncremental(x, prev_K, prev_V, P_q, P_k, P_v, P_o):
"""
Incremental Multi-Query Self-Attention for one step.
Args:
x: 一个形状为 [b, d] 的张量,表示当前步骤的查询向量
prev_K: 一个形状为 [b, m, k] 的张量,表示先前的键矩阵
prev_V: 一个形状为 [b, m, v] 的张量,表示先前的值矩阵
P_q: 一个形状为 [h, d, k] 的张量,表示查询的线性投影
P_k: 一个形状为 [d, k] 的张量,表示键的线性投影
P_v: 一个形状为 [d, v] 的张量,表示值的线性投影
P_o: 一个形状为 [h, d, v] 的张量,表示输出的线性投影
Returns:
y: 一个形状为 [b, d] 的张量,输出结果
new_K: 更新后的键矩阵,形状为 [b, m+1, k]
new_V: 更新后的值矩阵,形状为 [b, m+1, v]
"""
# 计算查询向量的线性投影,形状为 [b, h, k]
q = tf.einsum("bd, hdk->bhk", x, P_q)
# 更新键和值矩阵
new_K = tf.concat([prev_K, tf.expand_dims(tf.einsum("bd, dk->bk", x, P_k), axis=1)], axis=1)
new_V = tf.concat([prev_V, tf.expand_dims(tf.einsum("bd, dv->bv", x, P_v), axis=1)], axis=1)
# 计算查询与键的点积,形状为 [b, h, m+1]
logits = tf.einsum("bhk, bmk->bhm", q, new_K)
# 计算 softmax 权重
weights = tf.nn.softmax(logits)
# 使用权重对值进行加权求和
o = tf.einsum("bhm, bmv->bhv", weights, new_V)
# 线性投影并合并输出
y = tf.einsum("bhv, hdv->bd", o, P_o)
return y, new_K, new_V
性能分析
与传统多头注意力相似,在增量多查询注意力中,计算量依然是 ,而内存访问量为 。
通过移除键和值的「头」维度,增量解码时反复读取的 K/V 缓存缩小;渐近运算量仍为 ,加速主要来自内存带宽负担降低。
内存访问与计算之比为:
由于 项被头的数量 减少了,这使得增量推论的性能大幅提升。
假设你在进行语言模型生成,处理一批量大小 的 100 个单词(序列长度 ),而每个单词的向量维度 。
传统多头注意力的「内存访问-计算比」可能是:
而使用多查询注意力,假设头的数量 ,那么这个比率会变成:
我们简单动手算一下,就可以看到,多查询注意力在这组简化假设下降低了内存访问与运算量的比率;实际速度仍需测量。
训练策略
作者基于 WMT 2014 英德翻译任务进行评估。
模型方面采用 6 层编码器-解码器 Transformer 模型,设置如下:
- 头的数量
- ,使用学习的位置嵌入,并在 token 嵌入层和输出层之间共享权重。
训练 100,000 步(约 20 个 epoch),每个批量包含 128 个样本,每个样本有 256 个 token 的输入序列和 256 个 token 的目标序列。模型在 32 核 TPUv3 集群上训练,每个模型训练约 2 小时。
在 MQA 的模型中,作者将模型中所有的注意力层替换为 Multi-Query 注意力,并将前馈层的隐藏维度从 4096 增加到 5440,以保持总参数量与基线模型一致。
讨论
WMT14 EN-DE 结果
上表为作者提供的实验数据。
从表中可以发现,MQA 的开发集 ln(PPL) 为 1.439、BLEU 为 26.5,略差于基线的 1.424 和 26.7,但优于表中减少头数或键值维度的其他变体。WMT14 测试集使用 beam-4 时,MQA 的 BLEU 为 28.5,略高于基线的 28.4;因此「略差」只适用于上述开发集指标。
推理时间改进
速度表使用 TPUv2(8 核心);每个训练步骤处理 32,768 个输入 token 和 32,768 个目标 token。表中的训练时间除以 32,768,单位是每组「输入 token+目标 token」的摊销时间。
- **基线模型**:每步训练时间为 **433ms**。
- **多查询模型**:每步训练时间为 **425ms**,稍微比基线模型快。
每组输入与目标 token 的训练时间为:
-
基线模型:
-
MQA 模型:
推论测试则使用机器翻译模型的增量贪婪解码:1024 个序列,每个输入与目标序列各 128 token,平均每个 TPU 核心处理 128 个序列。
-
基线模型:
- 编码器部分耗时 222ms,即每个 token 的时间为 1.7µs。
- 解码器每步耗时 47ms,即每个 token 的解码时间为 46µs。
-
MQA 模型:
- 编码器部分耗时 195ms,即每个 token 的时间为 1.5µs。
- 解码器每步耗时 3.9ms,即每个 token 的解码时间为 3.8µs,显著快于基线模型。
结论
快又有效!
在几乎没有损失精度的前提下,大幅提升推论速度,特别是在自回归模型中,提升了约 10 倍!