返回论文笔记资料库
arXiv 2019语言模型与 Transformer论文笔记

MQA

共享 Key-Value

原始论文

Fast Transformer Decoding: One Write-Head is All You Need

论文作者

Noam Shazeer

发表版本
正式发表信息尚未核实
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)的关系。

python
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

再来是多头注意力机制,这是将多个点积注意力机制组合在一起,以提高模型的表现。

在下列函数中,参数意义表示:

  • dd:查询向量的维度
  • mm:键值对的数量
  • hh:注意力头的数量
  • kk:查询和键的线性投影维度
  • vv:值的线性投影维度
python
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)

接着我们扩展一下。

在一般训练中,我们会使用批量训练,这时候我们就需要对上面的函数进行修改。

python
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

在这里,作者对计算与内存访问进行了简化假设:

  1. m=nm = n:假设键和值的数量 mm 与查询的序列长度 nn 相等。
  2. k=v=dhk = v = \frac{d}{h}:根据 Transformer 原始论文的建议,查询和键的维度 kk 等于值的维度 vv,并且它们与特征维度 dd 成正比,比例因子为头的数量 hh。
  3. n≤dn ≤ d:假设序列长度 nn 小于或等于特征维度 dd。

根据这些假设,计算的总数量是 Θ(bnd2)Θ(bnd^2),其中 bb 是批量大小,nn 是序列长度,dd 是特征维度。这是由于每个 tf.einsum 操作的复杂度为 O(bnd2)O(bnd^2)。

内存访问大小的部分,所有张量的总内存需求为 O(bnd+bhn2+d2)O(bnd + bhn^2 + d^2):

  • 第一项 bndbnd 来自于输入 XX、键和值矩阵 MM、查询 QQ、键 KK、值 VV、输出 OO 和最终的输出 YY。
  • 第二项 bhn2bhn^2 来自于 logits 和权重。
  • 第三项 d2d^2 来自于投影张量 PqP_q、PkP_k、PvP_v 和 PoP_o。

内存访问与计算之比为:

O(1k+1bn)O\left(\frac{1}{k} + \frac{1}{bn}\right)

这个比值越低,对现代 GPU/TPU 硬件的性能越好,因为这类硬件的计算能力远高于内存带宽。

Multi-head Att (Incremental)

除了一般的多头注意力机制,另外一种是基于自回归的增量注意力机制。

python
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

作者沿用了之前的简化假设,并对增量推论进行了性能评估。

在整个推论过程中,运算量的总数为 Θ(bnd2)\Theta(bnd^2),其中 bb 是批量大小,nn 是序列长度,dd 是特征维度。

内存访问的总量为 Θ(bn2d+nd2)\Theta(bn^2d + nd^2):

  • 第一项 bn2dbn^2d 来自于每一步需要重新加载键 KK 和值 VV 的内存操作,这些张量的大小随着序列长度 nn 增加而增加。
  • 第二项 nd2nd^2 来自于查询、键和值的线性投影矩阵 Pq,Pk,Pv,PoP_q, P_k, P_v, P_o。

内存访问与计算之比率为:

Θ(nd+1b)\Theta\left(\frac{n}{d} + \frac{1}{b}\right)

当 n≈dn ≈ d 或 b≈1b ≈ 1 时,这个比率接近 1,说明内存带宽成为了现代计算硬件中的主要瓶颈。


比较简单的优化策略是增加批量大小,这样可以轻松减少内存访问与计算的比率。

另外一种是减少 nd\frac{n}{d} 比例,这比较困难,因为涉及到每一步重新加载键和值张量。优化方法包括限制序列长度 nn,或者只对局部范围进行注意力计算,压缩需要处理的记忆位置数量。

解决问题

为了减少键和值张量的大小,作者提出的具体方法是去掉 Key\text{Key} 和 Value\text{Value} 的「头」(heads)维度,但保留查询中的「头」维度,从而减少内存负担并提高效率。

Multi-Query Attention

多查询注意力(Multi-Query Attention)是多头注意力(Multi-Head Attention)的一种变体。

在传统多头注意力中,不同的「头」会拥有独立的查询(queries)、键(keys)、值(values)和输出,但多查询注意力则简化了这一结构:不同的头共享一组键和值,仅保留查询的多头结构。这样可以减少内存的负担并提高推论速度。

python
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)的实现代码:

python
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

性能分析

与传统多头注意力相似,在增量多查询注意力中,计算量依然是 Θ(bnd2)\Theta(bnd^2),而内存访问量为 Θ(bnd+bn2k+nd2)\Theta(bnd + bn^2k + nd^2)。

通过移除键和值的「头」维度,增量解码时反复读取的 K/V 缓存缩小;渐近运算量仍为 Θ(bnd2)\Theta(bnd^2),加速主要来自内存带宽负担降低。

内存访问与计算之比为:

Θ(1d+ndh+1b)\Theta\left(\frac{1}{d} + \frac{n}{dh} + \frac{1}{b}\right)

由于 nd\frac{n}{d} 项被头的数量 hh 减少了,这使得增量推论的性能大幅提升。

假设你在进行语言模型生成,处理一批量大小 b=128b = 128 的 100 个单词(序列长度 n=100n = 100),而每个单词的向量维度 d=512d = 512。

传统多头注意力的「内存访问-计算比」可能是:

nd+1b=100512+1128≈0.195+0.0078=0.2028\frac{n}{d} + \frac{1}{b} = \frac{100}{512} + \frac{1}{128} \approx 0.195 + 0.0078 = 0.2028

而使用多查询注意力,假设头的数量 h=8h = 8,那么这个比率会变成:

1d+ndh+1b\frac{1}{d} + \frac{n}{dh} + \frac{1}{b} =1512+100512×8+1128= \frac{1}{512} + \frac{100}{512 \times 8} + \frac{1}{128} ≈0.00195+0.0244+0.0078=0.03415\approx 0.00195 + 0.0244 + 0.0078 = 0.03415

我们简单动手算一下,就可以看到,多查询注意力在这组简化假设下降低了内存访问与运算量的比率;实际速度仍需测量。

训练策略

作者基于 WMT 2014 英德翻译任务进行评估。

模型方面采用 6 层编码器-解码器 Transformer 模型,设置如下:

  • dmodel=1024d_{model} = 1024
  • dff=4096d_{ff} = 4096
  • 头的数量 h=8h = 8
  • dk=dv=128d_k = d_v = 128,使用学习的位置嵌入,并在 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 的训练时间为:

  • 基线模型:

    43332,768=13.2μs\frac{433}{32,768} = 13.2\mu s
  • MQA 模型:

    42532,768=13.0μs\frac{425}{32,768} = 13.0\mu s

推论测试则使用机器翻译模型的增量贪婪解码: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 倍!