摘要
随着语言预训练的成功，开发更具扩展性且能高效利用大量未标注数据的架构变得尤为重要。为了提高效率，我们研究了在维持完整token级别表示时的冗余问题，尤其是对于仅需要序列单向量表示的任务。基于这一直觉，我们提出了Funnel-Transformer，它逐步将隐藏状态序列压缩为更短的序列，从而减少计算成本。更重要的是，通过将长度缩减节省的计算量（FLOPs）重新投入到构建更深或更宽的模型中，我们进一步提升了模型容量。此外，为了满足常见预训练目标对token级别预测的需求，Funnel-Transformer能够通过解码器从缩减的隐藏序列中恢复每个token的深层表示。实验表明，在可比或更少的FLOPs下，Funnel-Transformer在多种序列级别预测任务（包括文本分类、语言理解和阅读理解）上优于标准的Transformer。
1 引言
随着无监督语言预训练的成功[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]，神经自注意力模型（即Transformer）[13]的能力被推向了新的高度，推动了机器学习和自然语言处理（NLP）领域的显著进步。更重要的是，随着更多的计算量（FLOPs）被投入到更长的预训练和/或更大的模型中，预训练Transformer模型的性能持续提升。然而，预训练甚至微调最先进的自注意力模型成本极高，因为它们需要比传统NLP模型更多的FLOPs和内存资源。这在很大程度上限制了它们在更多领域的应用和成功。
面对这一挑战，越来越多的研究致力于降低预训练和微调自注意力模型的成本。从预训练后处理的角度，典型方法包括蒸馏、剪枝和量化等，这些方法试图通过利用更大模型中的丰富信号或学习去除不太重要的操作，从预训练良好的模型中派生出更轻量化的模型。另一类研究旨在设计一种不仅具有更低资源-性能比（更高效）且至少在某些领域能像Transformer一样扩展的架构。大多数此类方法基于Transformer主干，并专注于重新设计其构建模块。代表性解决方案包括寻找更好的微观操作或宏观模块设计[14, 15]，用局部操作（如卷积[16]和动态卷积[17]）替换全配对注意力，以及优化现有模块的隐藏层大小组合[18]。
在上述提到的各种方法中，一个共同的策略是识别冗余操作或表示，并用更高效的方式替代它们。受这一思路启发，在本研究中，我们将重点关注Transformer中所有层始终维持完整长度的隐藏表示序列所导致的潜在冗余。直观上，对于许多序列级别的NLP任务（如文本分类和排序），最常见的用例是从整个序列中提取单个向量，这并不一定需要保留所有信息到token级别的粒度。因此，对于此类任务，完整长度的隐藏状态序列可能包含显著的冗余。这与图像识别中的情况类似，卷积神经网络随着网络加深逐渐减少特征图的空间分辨率/大小。此外，语言学先验也鼓励将附近的token（词）逐渐合并为更大的语义单元（短语），这自然会导致表示序列的缩短。
具体来说，我们提出在自注意力模型中逐步减少隐藏表示的序列分辨率（即长度）。序列长度的减少可以立即显著节省FLOPs和内存。更重要的是，节省的计算资源可以直接重新投入到构建更深（或更宽）的模型中，以提升模型容量，而无需额外的计算负担。此外，为了解决常见预训练目标（如掩码语言建模（MLM）[2]）需要为每个token提供单独表示的挑战，我们设计了一种简单的策略，从缩短长度的隐藏状态中解码出完整长度的深层表示序列。因此，所提出的模型可以直接训练而无需修改预训练目标，并且可以用于需要token级别表示的下游任务。
实验表明，在可比甚至更少的FLOPs下，通过用序列分辨率换取深度，我们提出的模型在多种序列级别预测任务（包括文本分类、语言理解和阅读理解）上优于标准的Transformer。
2 方法
2.1 背景
Transformer架构
Transformer架构[13]是一种高度模块化的神经网络，其中每个Transformer层由两个子模块组成，即多头自注意力（S-Attn）和位置前馈网络（P-FFN）。这两个子模块都被残差连接和层归一化包裹。简而言之，给定长度为T的隐藏状态序列
h
=
[
h
1
;
…
;
h
T
]
h = [h_1; \dots; h_T]
h=[h1;…;hT]，单个Transformer层的计算可以表示为：
h
←
LayerNorm
(
h
+
S-Attn
(
Q
=
h
,
K
V
=
h
)
)
,
(
1
)
h \leftarrow \text{LayerNorm}(h + \text{S-Attn}(Q = h, KV = h)), \quad (1)
h←LayerNorm(h+S-Attn(Q=h,KV=h)),(1)
h i ← LayerNorm ( h i + P-FFN ( h i ) ) , ∀ i = 1 , … , T . ( 2 ) h_i \leftarrow \text{LayerNorm}(h_i + \text{P-FFN}(h_i)), \quad \forall i = 1, \dots, T. \quad (2) hi←LayerNorm(hi+P-FFN(hi)),∀i=1,…,T.(2)
预训练目标
最常用的预训练目标是由BERT[2]提出的掩码语言建模（MLM）。对于从大规模未标注数据集
D
D
D中采样的长度为T的自然语言序列
x
x
x，MLM目标首先通过随机替换
x
x
x中15%的token为特殊token [mask]来构建损坏序列
x
^
\hat{x}
x^，然后训练Transformer模型[2]基于
x
^
\hat{x}
x^重建原始
x
x
x，即：
max
θ
J
MLM
(
θ
)
=
E
x
∼
D
E
I
∑
i
∈
I
log
P
θ
(
x
i
∣
x
^
I
)
=
E
x
∼
D
E
I
∑
i
∈
I
log
exp
(
e
(
x
i
)
⊤
h
i
(
x
^
I
)
)
∑
x
′
exp
(
e
(
x
′
)
⊤
h
i
(
x
^
I
)
)
,
\max_{\theta} J_{\text{MLM}}(\theta) = \mathbb{E}_{x \sim D} \mathbb{E}_{I} \sum_{i \in I} \log P_{\theta}(x_i | \hat{x}_I) = \mathbb{E}_{x \sim D} \mathbb{E}_{I} \sum_{i \in I} \log \frac{\exp(e(x_i)^\top h_i(\hat{x}_I))}{\sum_{x'} \exp(e(x')^\top h_i(\hat{x}_I))},
θmaxJMLM(θ)=Ex∼DEIi∈I∑logPθ(xi∣x^I)=Ex∼DEIi∈I∑log∑x′exp(e(x′)⊤hi(x^I))exp(e(xi)⊤hi(x^I)),
其中
I
I
I是掩码token的位置，
x
^
I
\hat{x}_I
x^I的下标强调其对
I
I
I的依赖，
e
(
x
)
e(x)
e(x)表示token
x
x
x的嵌入，
h
i
(
x
^
I
)
h_i(\hat{x}_I)
hi(x^I)是Transformer模型在位置
i
i
i生成的最后一层隐藏状态。预训练后，整个模型在下游任务中进行微调。
为了展示我们提出模型的通用性，我们还实验了另一种预训练目标ELECTRA[5]。与MLM不同，ELECTRA依赖于一对联合训练的生成器和判别器。具体来说，生成器通常较小（大小为判别器的1/4），并通过MLM目标直接训练，即 max θ G J MLM ( θ G ) \max_{\theta_G} J_{\text{MLM}}(\theta_G) maxθGJMLM(θG)。然后，对于每个掩码位置，从生成器的重建分布中采样一个token替换[mask] token并形成新序列 x ~ \tilde{x} x~，即如果 i ∈ I i \in I i∈I，则 x ~ i ∼ P θ G ( x i ∣ x ^ I ) \tilde{x}_i \sim P_{\theta_G}(x_i | \hat{x}_I) x~i∼PθG(xi∣x^I)，否则 x ~ i = x i \tilde{x}_i = x_i x~i=xi。给定新序列 x ~ \tilde{x} x~，判别器通过二分类训练以区分 x ~ \tilde{x} x~中的每个token是真实的（与 x x x相同）还是伪造的（与 x x x不同）。预训练后，只有判别器会在微调中使用，生成器则被丢弃。
讨论
需要注意的是，上述介绍的两种预训练目标都要求能够为每个输入token生成隐藏状态，即
h
i
(
x
^
I
)
h_i(\hat{x}_I)
hi(x^I)和
h
i
(
x
~
)
h_i(\tilde{x})
hi(x~)。由于这一要求，保持完整长度的隐藏状态序列似乎是自然的。然而，相比之下，许多序列级别的下游任务（如分类或排序）只需要整个序列的单向量摘要。从根本上说，这表明在微调过程中通常需要某种压缩来去除不必要的冗余。这一观察立即引出了以下两个问题：
- 我们能否设计一种通用模型，通过将完整长度的隐藏状态序列压缩为更紧凑的形式，使其在表达能力相同的同时更高效？
- 在压缩表示的情况下，模型如何保留为预训练生成token级别表示的能力？
为了回答这两个问题，接下来我们将介绍我们提出的架构。
2.2 提出的架构
为了继承Transformer架构的高容量和优化优势，我们提出的模型保留了由残差连接和层归一化包裹的交错S-Attn和P-FFN子模块的整体骨架。但不同的是，为了实现表示压缩和计算减少，我们的模型采用了一个编码器，随着层数加深，逐渐减少隐藏状态序列的长度。此外，对于涉及逐token预测的任务（如预训练），我们使用一个简单的解码器从压缩的编码器输出中重建完整的token级别表示序列。
编码器
如图1左侧所示，编码器由多个连续的Transformer层块组成。在每个块内，隐藏状态的序列长度保持不变。但当从一个较低级别的块过渡到更高级别的块时，通过沿序列维度执行某种类型的池化来减少隐藏序列的长度，即：
h
′
=
Pooling
(
h
)
;
(
3
)
h' = \text{Pooling}(h); \quad (3)
h′=Pooling(h);(3)
其中
h
∈
R
T
×
D
h \in \mathbb{R}^{T \times D}
h∈RT×D，
h
′
∈
R
T
′
×
D
h' \in \mathbb{R}^{T' \times D}
h′∈RT′×D，且
T
′
<
T
T' < T
T′<T。重要的是，我们并不直接将池化后的序列
h
′
h'
h′输入到新块的第一个S-Attn层，而是仅使用池化序列
h
′
h'
h′来构建自注意力的查询向量（和残差信号），而未池化的序列
h
h
h则用于键和值向量，即：
h
←
LayerNorm
(
h
′
+
S-Attn
(
Q
=
h
′
;
K
V
=
h
)
)
.
(
4
)
h \leftarrow \text{LayerNorm}(h' + \text{S-Attn}(Q = h'; KV = h)). \quad (4)
h←LayerNorm(h′+S-Attn(Q=h′;KV=h)).(4)
请注意，这种特殊的S-Attn模块的输出序列长度与池化序列
h
′
h'
h′相同。为了理解这种设计的优势，可以将我们提出的“仅池化查询”变体与直接使用
h
′
h'
h′作为查询和键值向量的朴素方法进行比较，即
S-Attn
(
Q
=
h
′
;
K
V
=
h
′
)
\text{S-Attn}(Q = h'; KV = h')
S-Attn(Q=h′;KV=h′)：
- 在朴素方法中，压缩完全由池化操作控制，池化在注意力模块之前完成。因此，相对简单的池化方法（如平均池化）可能无法实现良好的压缩效果。
- 在“仅池化查询”变体中，压缩不仅取决于池化操作，还取决于自注意力如何加权求和未池化序列以形成每个池化向量。实际上，这种特殊的注意力可以被视为一种线性压缩，将 T T T个基向量组合成更少的 T ′ T' T′个“压缩基向量”。因此，以最小的计算开销，这种变体使压缩操作更具表现力。
在这种“仅池化查询”设计的基础上，我们发现对序列的每个滑动窗口应用最简单的步幅均值池化在实践中效果非常好。为简单起见，本文中我们仅实验了步幅为2、窗口大小为2的池化操作。因此，池化操作会将序列长度减半，每个池化隐藏状态对应于2个未池化隐藏向量的窗口。直观上，这种池化大致遵循了语言学先验，即附近的token可以逐渐合并（或压缩）为更大的语义单元。一旦池化和“仅池化查询”注意力将序列长度减半，编码器的其余计算只需遵循公式(2)和(1)中的标准更新。
最后，作为一个额外的实现细节，回想一下语言预训练中的一个特殊设计是在原始输入序列的开头添加一个特殊token [cls]，并使用与[cls]对应的最后一层隐藏状态（即 h 1 h_1 h1）作为序列的表示。为了防止池化破坏这种特殊结构，我们首先将[cls]隐藏状态与其余隐藏状态分开，并仅对其余隐藏状态应用池化。有关一些实际实现问题及其高效解决方案，请读者参阅附录A.1。
解码器
为了从缩短长度的编码器输出中恢复完整的隐藏状态序列，一个自然的想法是执行某种上采样操作。例如，在图像生成或超分辨率中，通常使用反卷积（转置卷积）或双线性插值等参数无关的调整大小方法来增加特征图的空间分辨率。因此，我们可以简单地将这些2D处理的思想适应到我们的1D情况，并对编码器输出应用适当的上采样。
然而，与图像领域中使用小扩展率（例如每次将序列长度增加2倍）进行多次上采样不同，我们选择使用具有大扩展率的单次上采样，如图1右侧所示。具体来说，给定来自M块编码器的长度为
T
M
=
T
/
2
M
−
1
T_M = T/2^{M-1}
TM=T/2M−1的输出序列
h
M
h_M
hM，我们直接通过将每个隐藏向量重复
2
M
−
1
2^{M-1}
2M−1次来上采样为完整长度的序列
h
up
=
[
h
up
,
1
;
…
;
h
up
,
T
]
h_{\text{up}} = [h_{\text{up},1}; \dots; h_{\text{up},T}]
hup=[hup,1;…;hup,T]：
∀
i
=
1
,
…
,
T
,
h
up
,
i
=
h
M
,
⌊
i
/
2
M
−
1
⌋
,
(
5
)
\forall i = 1, \dots, T, \quad h_{\text{up},i} = h_{M, \lfloor i / 2^{M-1} \rfloor}, \quad (5)
∀i=1,…,T,hup,i=hM,⌊i/2M−1⌋,(5)
其中
⌊
⋅
⌋
\lfloor \cdot \rfloor
⌊⋅⌋表示向下取整除法。然而，请注意，
h
up
h_{\text{up}}
hup中每
2
M
−
1
2^{M-1}
2M−1个连续向量完全相同，因此不包含详细的token级别信息。因此，我们进一步从编码器的第一个块中提取最后一层隐藏状态
h
1
h_1
h1，它仍然具有完整长度
T
T
T并包含未压缩的token级别信息。然后，将低级别表示
h
1
h_1
h1和上采样的高级别表示
h
up
h_{\text{up}}
hup相加，形成深层token级别表示
g
=
h
1
+
h
up
g = h_1 + h_{\text{up}}
g=h1+hup。实际上，这形成了一种残差/跳跃连接，使得详细的token信息能够传递，并可能实现更简单的优化。此外，我们在
g
g
g上堆叠了更多的Transformer层，以实现低级别和高级别特征的深度融合。在本文中，解码器中始终使用2个Transformer层。
需要强调的是，解码器仅在任务需要token级别预测时使用，例如在标准预训练或序列标注中。对于仅需要序列单向量表示的任务（如分类），解码器在预训练后被丢弃，仅微调编码器。最后，为了强调编码器的过滤/压缩特性及其形状，我们将提出的模型命名为Funnel-Transformer（F-TFM）。
2.3 复杂性与容量分析
在明确了架构设计后，我们现在分析序列压缩如何影响所提出模型的复杂性和容量，特别是与标准Transformer相比。
首先，对于一个包含S-Attn和P-FFN模块（隐藏大小为 D D D）的Transformer层，处理长度为 T T T的序列的复杂度为 O ( T 2 D + T D 2 ) O(T^2 D + T D^2) O(T2D+TD2)。因此，每次在编码器中将序列长度减半时，我们都能享受到超线性（超过一半）的复杂度降低。在实践中，由于 O ( T D 2 ) O(T D^2) O(TD2)项的常数较大，通常观察到接近线性的加速效果。当序列长度较长（如预训练中）时，超线性效果更为明显。因此，在相同的FLOPs下，我们可以用第1块中的一个完整长度层换取第 m m m块中的 2 m − 1 2^{m-1} 2m−1层，这提供了一种经济的方式来增加网络的深度。
另一方面，压缩长度层的容量显然受到正常完整长度层的上限限制。在大多数有损压缩的情况下，减少序列长度不可避免地会导致容量下降。好消息是，单个层的容量下降可以通过将节省的FLOPs重新投入到堆叠更多低成本层或增加模型宽度来很好地弥补。
作为一个具体示例，对于BERTBase大小的Transformer（即12层，隐藏大小为768，记为L12H768），我们可以构建一个包含3块的Funnel-Transformer，每块有6层，隐藏大小为768（记为B6-6-6H768）。尽管总共有18层，但在分类微调时，B6-6-6H768架构的FLOPs最多仅对应于 6 + 6 / 2 + 6 / 4 = 10.5 6 + 6/2 + 6/4 = 10.5 6+6/2+6/4=10.5个完整长度层，明显少于L12H768。更重要的是，正如我们将在实验中展示的那样，B6-6-6H768显著优于L12H768。虽然直观，但如何在这种深度与长度权衡下构建最优的块布局仍然是一个开放的挑战。在本文中，我们仅考虑相对规则的布局，并将更系统的研究留给未来工作。
最后，请注意，用序列分辨率换取深度或宽度会增加参数总数。例如，B6-6-6H768的参数数量是L12H768的1.5倍。在实践中，更多的参数可能会增加分布式训练中的通信成本以及内存消耗和内存访问时间。一个简单的补救措施是执行某种参数共享（如ALBERT中使用的），以恢复相同的参数数量。以B6-6-6H768为例，可以将第2和第3块中每两层的参数绑定，记为B6-3x2-3x2H768，从而恢复与L12H768相同的参数数量。然而，参数共享可能会导致性能损失。从根本上说，这带来了另一个权衡：使用更多参数的收益（容量）与成本（内存和通信成本）之间的权衡，这可能高度依赖于设备。
3 相关工作
据我们所知，之前没有工作在语言预训练下通过压缩隐藏状态序列长度来实现性能提升。同时，我们提出的模型与近期一项工作[19]提出的用于因果语言建模的自底向上模型非常相似。关键区别包括用于下采样的“仅池化查询”设计、上采样的实现方式以及我们的相对注意力参数化。另一个密切相关的想法是Power-BERT[20]，它在微调期间学习软消除不太“重要”的词向量。因此，在微调后的推理中，可以减少序列长度以实现加速。更广泛地说，我们的工作还与之前关于分层递归神经网络[21]和Transformer模型[22, 23]的研究相关。与这些方法不同，我们的模型不依赖于任何预定义的语义层次或边界，并且始终通过注意力捕获完整长度的依赖输入。
相比之下，我们的工作从计算机视觉领域汲取了许多灵感。具有残差连接的收缩编码器和扩展解码器框架在概念上类似于用于图像分割的ResUNet[24]。步幅池化也被广泛用于构建现代图像识别网络[25]。尽管有相似之处，除了数据域和计算模块的明显差异外，我们的编码器采用了特殊的“仅池化查询”设计以提高压缩效果，而我们的解码器仅需要一次具有大扩展率的上采样。
此外，图神经网络中的一系列研究尝试以不同方式逐步减少节点数量，并获得用于监督分类的单向量表示[26, 27, 28]。虽然这些方法可能可以作为替代压缩操作插入我们的模型中，但为监督图分类开发的压缩技术是否可以扩展到大规模语言预训练仍然是一个开放的问题。
4 实验
在本节中，我们通过首先预训练然后在下游任务中微调来实证评估提出的F-TFM。根据之前的工作，对于预训练，我们考虑两种常见设置：
-
Base规模：在Wikipedia + Book Corpus上以批量大小256预训练模型1M步。这是原始BERT[2]使用的设置。我们将依赖此设置进行F-TFM与标准Transformer的公平比较以及一些消融研究。
-
大规模：在XLNet[3]和ELECTRA[5]使用的五个数据集（Wikipedia + Book Corpus + ClueWeb + Gigaword + Common Crawl）上以批量大小8K预训练模型500K步。我们将在此规模下训练的F-TFM与之前的最先进方法进行比较。
对于微调，我们主要关注仅需要输入序列单向量表示的序列级别任务，因为F-TFM正是为此目的设计的。具体来说，这些任务包括用于语言理解的GLUE基准测试[29]、7个广泛使用的文本（情感/主题）分类任务（IMDB、AD、DBpedia、Yelp-2、Yelp-5、Amazon-2、Amazon-5）[30]，以及RACE阅读理解数据集[31]。此外，为了观察F-TFM在需要token级别预测时的表现，我们考虑了SQuAD问答任务，该任务要求模型从上下文段落中选择一个token范围作为答案。有关实验设置的更多细节，请读者参阅附录B。
最后，对于本文中实现的所有模型（包括在Base规模比较部分4.1中的Transformer基线），我们始终使用Transformer-XL[32]提出的相对位置注意力参数化（有关Transformer-XL的一些实现细节，请参阅附录A.2）。
4.1 Base规模结果
首先，我们评估F-TFM在相似计算量（即FLOPs）下与标准Transformer相比的表现。为此，我们考虑了标准Transformer的三种常用模型大小，即Large（L24H1024）、Base（L12H768）和Small（L6H768）。然后，对于每个Transformer基线，我们构建具有不同块布局和参数的F-TFM，同时确保F-TFM的FLOPs始终较少或相似。基于MLM预训练目标，GLUE基准测试和文本分类的结果如表1所示，其中还包括相对FLOPs和参数数量。在这里，我们可以得出一些关键观察结果：
-
在相似或更少的FLOPs下，通过用序列分辨率换取更多层数，F-TFM在大多数任务中（除了STS-B）优于标准Transformer，尤其是对于较小的模型。
-
当我们仅压缩序列长度而不增加深度（和参数数量）时，F-TFM在GLUE数据集的某些设置中可能会遭受一些性能损失。然而，随着模型大小的增加，这种性能差距会变小甚至消失。
-
此外，我们发现部分参数共享通常会损害性能。因此，应根据实际任务和计算设备进行权衡。
为了进一步测试F-TFM的通用性，我们还考虑了使用ELECTRA进行预训练。结果总结在表2中。总体而言，我们看到了类似的趋势，尽管在GLUE基准测试上的增益略小。这可能归因于直接复用为Transformer调优的两个关键超参数（判别器损失系数和生成器大小乘数）来训练F-TFM，而没有任何调整。
运行时间比较
虽然FLOPs计数提供了模型速度的总体概念，但它仍然与实际运行时间不同，尤其是在存在其他开销的情况下。因此，为了完整性，我们在附录C.2中展示了F-TFM在实际运行时间方面提供的加速效果。我们还在附录C.2中比较了F-TFM和TFM的实际内存占用情况。
4.2 大规模结果
鉴于F-TFM在Base规模下的令人鼓舞的结果，我们接下来考虑在大规模设置下训练F-TFM，并将其与在类似设置下预训练的先前模型进行比较。由于ELECTRA在性能上略优于MLM，我们将在所有大规模实验中使用ELECTRA目标。给定不同大小的预训练F-TFM，我们首先在表3中比较了GLUE基准测试上的微调性能。与Base规模结果类似，在FLOPs较少或相当的情况下，F-TFM在大多数任务中优于相应的基线模型，表明F-TFM具有良好的扩展性。我们还在7个文本分类任务上测试了模型，但由于篇幅限制，请读者参阅附录C.1。
接下来，我们考虑RACE数据集，该数据集与GLUE基准测试有很大不同。RACE本质上是一个需要复杂推理的多项选择阅读理解任务，尽管它可以被形式化为分类正确选项的任务。此外，RACE中的段落通常较长。对F-TFM来说，这既是一个挑战（因为它需要详细的推理），也是一个压缩长段落的机会。正如我们在表4中看到的，F-TFM相比所有先前模型都取得了更好的性能。特别是在Base模型组中，性能提升非常显著。这表明F-TFM在涉及长文本和推理的序列级别任务中也能表现出色。
最后，尽管F-TFM主要是为仅需要序列级别表示的任务设计的，但通过额外微调解码器，也可以将F-TFM应用于token级别任务。为了测试这种能力，我们在SQuAD数据集上微调F-TFM，并在表5中与先前模型进行比较。虽然F-TFM在Base组中大幅优于先前模型，但在Large模型组中，FLOPs约为83%的F-TFM（B10-10-10）仍然落后于始终维持完整token级别表示的标准Transformer。这表明当详细的token级别信息至关重要时，序列压缩可能会损害性能。另一方面，与SQuAD1.1的结果相比，F-TFM在SQuAD2.0上的表现相对更好，
这进一步表明F-TFM在序列级别任务中的普遍有效性。
4.3 消融研究
最后，基于GLUE基准测试，我们对F-TFM中各种设计的重要性进行了一系列消融研究，包括块布局设计、池化操作类型、“仅池化查询”技术、维护单独的[cls]向量以及Transformer-XL参数化的使用。
-
池化操作：除了我们在F-TFM中最终采用的均值池化外，我们还测试了两种类型的池化操作：
(1) 第一种是第2节中描述的步幅均值/最大池化。
(2) 第二种旨在选择“中心”状态的子集，这些隐藏向量在之前的S-Attn层中被关注最多，因此可能携带序列中最关键的信息。具体来说，给定之前S-Attn层的注意力图，我们沿头数和查询长度维度对分数进行求和，得到每个位置的分数。然后，我们简单地选择前50%的状态以实现相同的压缩率。请注意，这种池化操作本质上与Power-BERT[20]中的重要状态选择过程相同。 -
“仅池化查询”设计
-
在池化操作中分离[cls]
-
块布局设计：在我们的实验中，所有模型实际上都采用了3块设计。在这里，我们将3块设计与2块和4块设计进行比较。
-
Transformer-XL[32]提出的相对注意力参数化：我们将此参数化与BERT[2]中使用的学习绝对位置嵌入进行比较。
消融结果包含在表6中。为了节省计算资源，表6中模型隐藏状态的大小设置为512。从消融结果中，我们可以得出以下观察结果：
- 比较不同的池化操作（(1)、(5)和(6)），我们发现均值池化和最大池化操作的性能相似，但它们显著优于利用注意力分数（Top-Attn池化）选择“中心”状态的想法。
- 分别比较(1)与(2)和(3)，我们发现两种特殊设计（即“仅池化查询”和维护单独的非池化[cls]）都能为所提出的模型带来明显的改进。
- 比较(1)和(4)，我们发现相对位置参数化是所提出的F-TFM性能的关键。我们怀疑池化操作可能会破坏绝对位置编码携带的位置信息，这些信息仅在输入嵌入层注入模型。因此，较高的块可能没有足够的位置信息来学习足够好的注意力模式。相比之下，在相对位置注意力方案下，位置信息被注入到每一层。因此，为了在使用绝对位置嵌入的F-TFM上取得良好结果，可能需要将绝对位置嵌入注入到每个注意力层中。实际上，Transformer在计算机视觉检测问题中的一项近期应用表明，将位置嵌入注入每一层非常重要[33]。
- 最后，我们研究了块布局设计在我们框架中的影响。以B6-6-6作为3块基准，我们考虑了另外两种具有相似FLOPs和参数数量的布局设计。具体来说，我们考虑了2块设计的B8-8和4块设计的B5-5-5-5。比较(1)、(7)和(8)的结果，我们发现3块设计（B6-6-6）的性能最佳，显著优于4块设计，略优于2块设计。然而，如果我们进一步考虑FLOPs/参数数量，3块设计的优越性更加明显。因此，在正文中，我们始终使用3块设计。
5 结论与讨论
在本研究中，在预训练-微调范式下，我们探索了语言处理中一个被广泛忽视的复杂性维度。通过提出的Funnel-Transformer，我们展示了如何以简单的形式压缩序列分辨率以节省计算量，以及如何将节省的FLOPs重新投入到提高模型容量和性能中。未来研究的开放挑战包括改进压缩方案、优化块布局设计以及更有效地重新利用节省的FLOPs。此外，将Funnel-Transformer与知识蒸馏和量化等模型压缩技术结合，将是增强实际应用影响力的重要方向。
以下是翻译为汉语的内容：
A \textbf{A} A 实现优化 \textbf{实现优化} 实现优化
A.1 用于分离 [cls] 的技巧的序列截断
如第 2.2 节所述，为了避免破坏预训练中常用的 [cls] 结构，我们不对 [cls] 应用池化操作，并保持与 [cls] 对应的隐藏状态不变。虽然概念上很简单，但由于这种操作导致的“不规则”序列长度，简单的实现可能会使计算速度降低 15%。具体来说，假设输入样本的序列长度是 2 的幂次方，即 2 p 2^p 2p，在预训练阶段通常为 512。在保持 [cls] 不变的情况下进行一次池化操作后，池化后的序列长度变为 2 p − 1 + 1 2^{p-1}+1 2p−1+1，这不再是 2 的幂次方。因此，它可能导致内存不对齐和加速器中并行计算能力的浪费，从而导致显著的速度损失。
为了解决这个问题，我们采用了一种简单的策略，即在池化后截断最后一个 token。形式上，将池化后的隐藏状态表示为 h = { h [ c l s ] , h 1 , ⋯ , h 2 p − 1 } \mathbf{h} = \{ h_{[ \mathrm{cls}] }, h_{1}, \cdots , h_{2^{p- 1}}\} h={h[cls],h1,⋯,h2p−1}，截断操作可以表示为：
h ^ = t r u n c a t e ( h ) = [ h [ c l s ] , h 1 , ⋯ , h 2 p − 1 − 1 ] ( 6 ) \hat{\mathbf{h}}=\mathrm{truncate}(\mathbf{h})=[h_{[\mathrm{cls}]},h_1,\cdots,h_{2^{p-1}-1}]\quad(6) h^=truncate(h)=[h[cls],h1,⋯,h2p−1−1](6)
通过这个简单的技巧，我们可以始终保持序列长度为 2 的幂次方，从而避免因维护独立的 [cls] 隐藏状态而导致的速度下降。
A.2 相对位置注意力的实现
在本工作中，我们使用了 TransformerXL[32] 中提出的相对位置注意力参数化方法。为了方便进一步讨论，我们首先回顾该参数化的细节。以单头注意力为例，设 T , D T,D T,D 分别为序列长度和隐藏维度。那么，位置 i i i 和 j j j 之间的预 softmax 注意力分数 A i j A_{ij} Aij 由两项组成：
A i j = ( W Q h i + v ) ⊤ ( W K h j ) ⏟ 内容项 + ( W Q h i + u ) ⊤ ( W R r i − j ) ⏟ 位置项 . (7) A_{ij}=\underbrace{(W_Qh_i+v)^\top(W_Kh_j)}_{\text{内容项}}+\underbrace{(W_Qh_i+u)^\top(W_Rr_{i-j})}_{\text{位置项}}\:.\tag{7} Aij=内容项 (WQhi+v)⊤(WKhj)+位置项 (WQhi+u)⊤(WRri−j).(7)
其中， v , u ∈ R D v, u \in \mathbb{R}^D v,u∈RD 是两个可训练的偏置向量， W Q , W K , W R ∈ R D × D W_Q, W_K, W_R \in \mathbb{R}^{D \times D} WQ,WK,WR∈RD×D 是三个可训练的投影矩阵， r i − j ∈ R D r_{i-j} \in \mathbb{R}^D ri−j∈RD 是表示相对距离 i − j i-j i−j 的正弦位置编码。
为了计算整个注意力分数矩阵
A
\mathbf{A}
A，内容项可以通过两个头部投影和一个复杂度为
O
(
T
D
2
+
T
2
D
)
O(TD^2 + T^2D)
O(TD2+T2D) 的外积轻松获得：
A
c
o
n
t
e
n
t
=
(
H
W
Q
+
v
)
(
H
W
K
)
⊤
,
\mathbf{A}^{\mathrm{content}} = (\mathbf{H}W_Q + v)(\mathbf{H}W_K)^\top,
Acontent=(HWQ+v)(HWK)⊤,
其中
H
=
[
h
1
,
⋯
,
h
T
]
∈
R
T
×
D
\mathbf{H} = [h_1, \cdots, h_T] \in \mathbb{R}^{T \times D}
H=[h1,⋯,hT]∈RT×D 将所有隐藏状态收集到一个矩阵中。然而，位置项不能以相同的方式计算，因为每个
A
i
j
p
o
s
i
t
i
o
n
A_{ij}^\mathrm{position}
Aijposition 对应一个不同的
r
i
−
j
r_{i-j}
ri−j。因此，一种朴素的方法是将
T
2
T^2
T2 对位置编码堆叠成一个张量
R
^
∈
R
T
×
T
×
D
\hat{\mathbf{R}} \in \mathbb{R}^{T \times T \times D}
R^∈RT×T×D，其中
R
^
i
j
=
r
i
−
j
\hat{\mathbf{R}}_{ij} = r_{i-j}
R^ij=ri−j，然后执行以下张量积：
A
p
o
s
i
t
i
o
n
=
e
i
n
s
u
m
(
"
i
d
,
i
j
d
−
>
i
j
′
′
,
H
W
Q
+
u
,
R
^
W
R
)
.
\mathbf{A}^{\mathrm{position}} = \mathrm{einsum}("\mathrm{id},\mathrm{ijd->ij''}, \mathbf{H}W_{Q} + u, \hat{\mathbf{R}}W_{R}).
Aposition=einsum("id,ijd−>ij′′,HWQ+u,R^WR).
需要注意的是，头部投影
R
W
K
\mathbf{R}W_K
RWK 的复杂度为
O
(
T
2
D
2
)
O(T^2D^2)
O(T2D2)，内存占用为
O
(
T
2
D
)
O(T^2D)
O(T2D)，这主导了所有其他计算。
A.2.1 标准解决方案：Gather/Shift
为了解决上述计算负担，一种常见的技术是收集一个矩阵
R
∈
R
2
T
−
1
×
D
\mathbf{R} \in \mathbb{R}^{2T-1 \times D}
R∈R2T−1×D，其中
R
=
[
r
T
−
1
,
…
,
r
0
,
⋯
,
r
1
−
T
]
,
\mathbf{R} = [r_{T-1}, \ldots, r_{0}, \cdots, r_{1-T}],
R=[rT−1,…,r0,⋯,r1−T],
包括从最大可能距离值
T
−
1
T-1
T−1 到最小可能值
1
−
T
1-T
1−T 的所有可能位置编码。完整的
R
^
\hat{\mathbf{R}}
R^ 可以通过从
R
\mathbf{R}
R 中收集特定元素来形成，使用形状为
[
T
×
T
]
[T \times T]
[T×T] 的索引矩阵
I
\mathbf{I}
I，即
R
^
=
g
a
t
h
e
r
(
R
,
I
)
,
I
i
j
=
T
+
i
−
j
.
\mathbf{\hat{R}} = \mathrm{gather}(\mathbf{R}, \mathbf{I}), \quad I_{ij} = T + i - j.
R^=gather(R,I),Iij=T+i−j.
从数学上讲，这相当于使用一个置换张量
P
∈
R
T
×
T
×
2
T
−
1
\mathbf{P} \in \mathbb{R}^{T \times T \times 2T-1}
P∈RT×T×2T−1 乘以
R
\mathbf{R}
R，即
R
^
=
P
R
\hat{\mathbf{R}} = \mathbf{PR}
R^=PR，其中
P
i
j
∈
R
2
T
−
1
\mathbf{P}_{ij} \in \mathbb{R}^{2T-1}
Pij∈R2T−1 是一个独热向量，用于选择/收集
R
\mathbf{R}
R 的单个位置。
以下是翻译为汉语的内容：
由于注意力分数的计算仅涉及线性操作，我们可以将位置项的计算重新排列如下：
A p o s i t i o n = einsum("id,ijd->ij",H W Q + u , ( PR ) W R ) = einsum ( " ijk,jk->ij",P, [ ( H W Q + v ) ( R W R ) ⊤ ] ) = gather ( ( H W Q + v ) ( R W R ) ⊤ , I ) \begin{aligned} \mathbf{A}^{\mathrm{position}} &= \text{einsum("id,ijd->ij",H}W_Q+u,(\text{PR})W_R) \\ &= \text{einsum}\Big("\text{ijk,jk->ij",P,}\Big[(\textbf{H}W_Q+v)(\textbf{R}W_R)^\top\Big]\Big) \\ &= \text{gather}\Big((\mathbf{H}W_Q+v)(\mathbf{R}W_R)^\top,\mathbf{I}\Big) \end{aligned} Aposition=einsum("id,ijd->ij",HWQ+u,(PR)WR)=einsum("ijk,jk->ij",P,[(HWQ+v)(RWR)⊤])=gather((HWQ+v)(RWR)⊤,I)
需要注意的是，假设收集 T 2 T^2 T2 个元素的复杂度仅为 O ( T 2 ) O(T^2) O(T2)（这在 CPU/GPU 上成立），这一技巧将计算复杂度降低回 O ( 2 T D 2 + 2 T 2 D ) O(2TD^2+2T^2D) O(2TD2+2T2D)。实际上，收集操作可以通过一种更高效的智能 reshape 操作来实现。
A.2.2 针对 TPU 的优化：分解的相对位置注意力
然而，在 TPU 上，收集 T 2 T^2 T2 个元素的复杂度仅为 O ( T 2 ) O(T^2) O(T2) 的假设并不成立。相反，我们发现这种收集操作在 TPU 上明显更慢。因此，我们在此考虑另一种在 TPU 上显著更快的实现方式。
首先，我们将位置项重写如下：
A i j p o s i t i o n = ( W Q h i + u ) ⊤ ( W R r i − j ) = [ W R ⊤ ( W Q h i + u ) ⏟ q i ] ⊤ r i − j = q i ⊤ r i − j . (8) \begin{aligned} A_{ij}^{\mathrm{position}} &= (W_{Q}h_{i}+u)^{\top}(W_{R}r_{i-j}) \\ &= \left[\underbrace{W_{R}^{\top}(W_{Q}h_{i}+u)}_{q_{i}}\right]^{\top}r_{i-j} \\ &= q_{i}^{\top}r_{i-j}. \end{aligned}\tag{8} Aijposition=(WQhi+u)⊤(WRri−j)= qi WR⊤(WQhi+u) ⊤ri−j=qi⊤ri−j.(8)
为了便于推导，我们引入了
q
i
q_i
qi 的表示。然后，回顾
r
i
−
j
r_{i-j}
ri−j 是由正弦和余弦分量组成的正弦编码，即
r
i
−
j
=
cat
(
sin
i
−
j
,
cos
i
−
j
)
r_{i-j} = \text{cat}(\sin_{i-j}, \cos_{i-j})
ri−j=cat(sini−j,cosi−j)，其中
sin
t
=
[
sin
(
t
/
1000
0
2
/
D
)
,
sin
(
t
/
1000
0
4
/
D
)
,
⋯
,
sin
(
t
/
1000
0
D
/
D
)
]
∈
R
D
/
2
,
cos
t
=
[
cos
(
t
/
1000
0
2
/
D
)
,
cos
(
t
/
1000
0
4
/
D
)
,
⋯
,
cos
(
t
/
1000
0
D
/
D
)
]
∈
R
D
/
2
.
\sin_{t} = \left[\sin\left(t/10000^{2/D}\right), \sin\left(t/10000^{4/D}\right), \cdots, \sin\left(t/10000^{D/D}\right)\right] \in \mathbb{R}^{D/2}, \\ \cos_{t} = \left[\cos\left(t/10000^{2/D}\right), \cos\left(t/10000^{4/D}\right), \cdots, \cos\left(t/10000^{D/D}\right)\right] \in \mathbb{R}^{D/2}.
sint=[sin(t/100002/D),sin(t/100004/D),⋯,sin(t/10000D/D)]∈RD/2,cost=[cos(t/100002/D),cos(t/100004/D),⋯,cos(t/10000D/D)]∈RD/2.
因此，我们同样将上述定义的
q
i
q_i
qi 分为两部分，即
q
i
=
c
a
t
(
q
i
sin
,
q
i
cos
)
.
q_{i} = \mathrm{cat}(q_{i}^{\sin}, q_{i}^{\cos}).
qi=cat(qisin,qicos).
根据这些定义，我们可以将公式 (8) 进一步分解为两项：
A
i
j
p
o
s
i
t
i
o
n
=
q
i
⊤
r
i
−
j
=
q
i
sin
⊤
sin
i
−
j
+
q
i
cos
⊤
cos
i
−
j
.
A_{ij}^{\mathrm{position}} = q_{i}^{\top}r_{i-j} = q_{i}^{\sin\top}\sin_{i-j} + q_{i}^{\cos\top}\cos_{i-j}.
Aijposition=qi⊤ri−j=qisin⊤sini−j+qicos⊤cosi−j.
现在，利用三角恒等式
sin
(
a
−
b
)
=
sin
(
a
)
cos
(
b
)
−
cos
(
a
)
sin
(
b
)
\sin(a-b) = \sin(a)\cos(b) - \cos(a)\sin(b)
sin(a−b)=sin(a)cos(b)−cos(a)sin(b) 和
cos
(
a
−
b
)
=
cos
(
a
)
cos
(
b
)
+
sin
(
a
)
sin
(
b
)
\cos(a-b) = \cos(a)\cos(b) + \sin(a)\sin(b)
cos(a−b)=cos(a)cos(b)+sin(a)sin(b)，这两项可以分别重新表示为：
q
i
sin
⊤
sin
i
−
j
=
q
i
sin
⊤
[
sin
i
⊙
cos
j
−
cos
i
⊙
sin
j
]
=
q
i
sin
⊤
(
sin
i
⊙
cos
j
)
−
q
i
sin
⊤
(
cos
i
⊙
sin
j
)
=
[
q
i
sin
⊙
sin
i
]
⊤
cos
j
+
[
q
i
sin
⊙
(
−
cos
i
)
]
⊤
sin
j
\begin{aligned} q_{i}^{\sin\top}\sin_{i-j} &= q_{i}^{\sin\top}[\sin_{i} \odot \cos_{j} - \cos_{i} \odot \sin_{j}] \\ &= q_{i}^{\sin\top}(\sin_{i} \odot \cos_{j}) - q_{i}^{\sin\top}(\cos_{i} \odot \sin_{j}) \\ &= \left[q_{i}^{\sin} \odot \sin_{i}\right]^{\top} \cos_{j} + \left[q_{i}^{\sin} \odot (-\cos_{i})\right]^{\top} \sin_{j} \end{aligned}
qisin⊤sini−j=qisin⊤[sini⊙cosj−cosi⊙sinj]=qisin⊤(sini⊙cosj)−qisin⊤(cosi⊙sinj)=[qisin⊙sini]⊤cosj+[qisin⊙(−cosi)]⊤sinj
和
q
i
cos
⊤
cos
i
−
j
=
q
i
cos
⊤
[
cos
i
⊙
cos
j
+
sin
i
⊙
sin
j
]
=
q
i
cos
⊤
(
cos
i
⊙
cos
j
)
+
q
i
cos
⊤
(
sin
i
⊙
sin
j
)
=
[
q
i
cos
⊙
cos
i
]
⊤
cos
j
+
[
q
i
cos
⊙
sin
i
]
⊤
sin
j
\begin{aligned} q_{i}^{\cos\top}\cos_{i-j} &= q_{i}^{\cos\top}[\cos_{i} \odot \cos_{j} + \sin_{i} \odot \sin_{j}] \\ &= q_{i}^{\cos\top}(\cos_{i} \odot \cos_{j}) + q_{i}^{\cos\top}(\sin_{i} \odot \sin_{j}) \\ &= \left[q_{i}^{\cos} \odot \cos_{i}\right]^{\top} \cos_{j} + \left[q_{i}^{\cos} \odot \sin_{i}\right]^{\top} \sin_{j} \end{aligned}
qicos⊤cosi−j=qicos⊤[cosi⊙cosj+sini⊙sinj]=qicos⊤(cosi⊙cosj)+qicos⊤(sini⊙sinj)=[qicos⊙cosi]⊤cosj+[qicos⊙sini]⊤sinj
因此，将这两部分结合起来，可以得到：
q i ⊤ r i − j = q i sin ⊤ sin i − j + q i cos ⊤ cos i − j = [ q i sin ⊙ sin i ] ⊤ cos j + [ q i sin ⊙ ( − cos i ) ] ⊤ sin j + [ q i cos ⊙ cos i ] ⊤ cos j + [ q i cos ⊙ sin i ] ⊤ sin j = { [ q i sin ⊙ sin i ] ⊤ cos j + [ q i cos ⊙ cos i ] ⊤ cos j } + { [ q i sin ⊙ ( − cos i ) ] ⊤ sin j + [ q i cos ⊙ sin i ] ⊤ sin j } = [ q i sin , q i cos ⏟ = q i ] ⊙ cat ( sin i , cos i ) ⏟ = ϕ i + [ cat ( q i sin , q i cos ) ⏟ = q i ⊙ cat ( − cos i , sin i ) ⏟ = π i ] ⊤ cat ( sin j , sin j ) ⏟ = ω j = [ q i ⊙ ϕ i ] ⊤ ψ j + [ q i ⊙ π i ] ⊤ ω j , \begin{aligned} q_{i}^{\top}r_{i-j} &= q_{i}^{\sin\top}\sin_{i-j} + q_{i}^{\cos\top}\cos_{i-j} \\ &= \left[q_{i}^{\sin} \odot \sin_{i}\right]^{\top} \cos_{j} + \left[q_{i}^{\sin} \odot (-\cos_{i})\right]^{\top} \sin_{j} \\ &\quad + \left[q_{i}^{\cos} \odot \cos_{i}\right]^{\top} \cos_{j} + \left[q_{i}^{\cos} \odot \sin_{i}\right]^{\top} \sin_{j} \\ &= \left\{\left[q_{i}^{\sin} \odot \sin_{i}\right]^{\top} \cos_{j} + \left[q_{i}^{\cos} \odot \cos_{i}\right]^{\top} \cos_{j}\right\} \\ &\quad + \left\{\left[q_{i}^{\sin} \odot (-\cos_{i})\right]^{\top} \sin_{j} + \left[q_{i}^{\cos} \odot \sin_{i}\right]^{\top} \sin_{j}\right\} \\ &= \left[\underbrace{q_{i}^{\sin}, q_{i}^{\cos}}_{=q_{i}}\right] \odot \underbrace{\text{cat}(\sin_{i}, \cos_{i})}_{=\phi_{i}} \\ &\quad + \left[\underbrace{\text{cat}(q_{i}^{\sin}, q_{i}^{\cos})}_{=q_{i}} \odot \underbrace{\text{cat}(-\cos_{i}, \sin_{i})}_{=\pi_{i}}\right]^{\top} \underbrace{\text{cat}(\sin_{j}, \sin_{j})}_{=\omega_{j}} \\ &= [q_{i} \odot \phi_{i}]^{\top} \psi_{j} + [q_{i} \odot \pi_{i}]^{\top} \omega_{j}, \end{aligned} qi⊤ri−j=qisin⊤sini−j+qicos⊤cosi−j=[qisin⊙sini]⊤cosj+[qisin⊙(−cosi)]⊤sinj+[qicos⊙cosi]⊤cosj+[qicos⊙sini]⊤sinj={[qisin⊙sini]⊤cosj+[qicos⊙cosi]⊤cosj}+{[qisin⊙(−cosi)]⊤sinj+[qicos⊙sini]⊤sinj}= =qi qisin,qicos ⊙=ϕi cat(sini,cosi)+ =qi cat(qisin,qicos)⊙=πi cat(−cosi,sini) ⊤=ωj cat(sinj,sinj)=[qi⊙ϕi]⊤ψj+[qi⊙πi]⊤ωj,
其中， ϕ i , ψ j , π i , ω j \phi_i, \psi_j, \pi_i, \omega_j ϕi,ψj,πi,ωj 是通过以不同方式连接对应 i i i 和 j j j 的余弦和正弦向量形成的 4 种位置编码。需要注意的是，最后一行的每一项都具有分解形式，可以通过外积计算，就像标准的内容项一样。因此，通过将所有位置（即 i = 1 , … , T i=1,\ldots,T i=1,…,T 和 j = 1 , … , T j=1,\ldots,T j=1,…,T）的 ϕ i , ψ j , π i , ω j \phi_i, \psi_j, \pi_i, \omega_j ϕi,ψj,πi,ωj 分别堆叠成对应的 Φ , Ψ , Π , Ω ∈ R T × D \Phi, \Psi, \Pi, \Omega \in \mathbb{R}^{T \times D} Φ,Ψ,Π,Ω∈RT×D，完整的位置项可以简单地表示为：
A position = { [ ( H W Q + u ) W R ⊤ ] ⊙ Φ } Ψ ⊤ + { [ ( H W Q + u ) W R ⊤ ] ⊙ Π } Ω ⊤ , \mathbf{A}^{\text{position}} = \left\{\left[(\mathbf{H}W_Q + u)W_R^\top\right] \odot \mathbf{\Phi}\right\} \mathbf{\Psi}^\top + \left\{\left[(\mathbf{H}W_Q + u)W_R^\top\right] \odot \mathbf{\Pi}\right\} \mathbf{\Omega}^\top, Aposition={[(HWQ+u)WR⊤]⊙Φ}Ψ⊤+{[(HWQ+u)WR⊤]⊙Π}Ω⊤,
其复杂度为 O ( 2 T D 2 + 4 T 2 D ) O(2TD^2 + 4T^2D) O(2TD2+4T2D)，与内容项的复杂度相当。
A.3 潜在模型扩展
在本节中，我们讨论了 Funnel-Transformer 的一些潜在模型扩展。如第 2 节所述，Funnel-Transformer 可以分为具有压缩功能的编码器和恢复完整长度 token 级别表示的解码器。为了进一步扩展所提出的模型，首先需要注意的是，编码器-解码器框架可以表述为更一般的形式：
h
enc
=
Encoder
(
x
enc
)
,
h
dec
=
Decoder
(
h
enc
,
x
dec
)
,
h_{\text{enc}} = \text{Encoder}(x_{\text{enc}}), \\ h_{\text{dec}} = \text{Decoder}(h_{\text{enc}}, x_{\text{dec}}),
henc=Encoder(xenc),hdec=Decoder(henc,xdec),
其中，
x
enc
x_{\text{enc}}
xenc 是编码器输入序列，
x
dec
x_{\text{dec}}
xdec 是可选的、针对特定问题的解码器输入。编码器的目标是将输入序列
x
enc
x_{\text{enc}}
xenc 压缩为长度减少的隐藏表示
h
enc
h_{\text{enc}}
henc。然后，解码器在给定解码器输入
h
enc
h_{\text{enc}}
henc（如果有）的情况下，从
h
enc
h_{\text{enc}}
henc 中提取相关信息/表示，以解决当前的具体 NLP 问题。接下来，我们将展示如何将 Funnel-Transformer 的一般形式实例化为特定形式，以解决相应的 NLP 问题。
序列级别预测
这本质上是我们大多数实验中考虑的情况，即我们希望获得输入序列的向量表示，例如文本分类。在这种情况下，我们实际上不需要解码器输入 x dec x_{\text{dec}} xdec（即 x dec = ∅ x_{\text{dec}} = \emptyset xdec=∅），解码器只需从 h enc h_{\text{enc}} henc 中提取与 [cls] token 对应的隐藏表示，并将其输入到任务特定的结构（例如分类器）中。
Token 级别预测
在 token 级别预测任务中，例如 MLM 预训练、SQuAD 和序列标注，我们需要一个解码器从压缩序列 h enc h_{\text{enc}} henc 中恢复 token 级别的表示。在许多情况下， x dec x_{\text{dec}} xdec 可以是原始序列或其 token 级别的隐藏表示，以提供每个 token 的细粒度低级信息，从而简化优化过程。在本文中，我们利用第一个块（在第一次池化操作之前）的最后一层隐藏状态作为额外的解码器输入。但对于利用额外输入信号的问题，例如 XLNet [3] 中用于排列语言建模的排列顺序，可以通过解码器输入 x dec x_{\text{dec}} xdec 将这些额外信息注入 Funnel-Transformer，以（近似）恢复对注意力机制的更复杂控制。
序列到序列问题
另一类重要的 NLP 任务是序列到序列问题，包括机器翻译、文本摘要和对话生成，其最先进的解决方案是传统的编码器-解码器框架。因此，Funnel-Transformer 自然适用于这些任务，其中解码器输入 x dec x_{\text{dec}} xdec 对应目标文本序列，编码器输入 x enc x_{\text{enc}} xenc 对应源文本序列。这种方式下，与传统模型的关键区别在于 Funnel-Transformer 提供了源端压缩功能。
总体而言，我们总结了一些将第 2.2 节中提出的 Funnel-Transformer 扩展到 NLP 问题的潜在方向。最后，尽管本文主要讨论 NLP 任务，但 Funnel-Transformer 也可以应用于任何处理序列数据的任务，例如时间序列和视频流分析。
实验设置与超参数
B.1 预处理与分词
在本工作进行的所有实验中，我们直接采用了 BERT [2] 最初使用的“uncased” WordPiece 模型，其词汇表大小约为 30K。除了将文本转换为小写以及 WordPiece 分词器中包含的默认预处理外，我们执行的唯一额外预处理是在 7 个文本分类任务中移除一些 HTTP 符号。
B.2 预训练
用于两种不同预训练设置的超参数总结在表 7 中。一个例外是基础规模下 B10-10-10H1024 模型使用的学习率。具体来说，我们发现当深度超过 24 层（在 B10-10-10H1024 的情况下）时，训练可能会变得不稳定，尤其是对于 MLM（掩码语言建模）目标。因此，我们在基础规模预训练期间将 B10-10-10H1024 F-TFM 的学习率降低到 8e-5。这会导致训练速度变慢，并可能略微影响微调性能。然而，当批量大小增加时（例如在大规模设置中），我们没有观察到这种不稳定性。
对于 ELECTRA，有两个额外的重要超参数，即判别器损失系数和生成器的相对大小乘数。在本工作中，我们完全没有调整这两个超参数，而是直接使用原始论文中的数值，即对于所有使用 ELECTRA 训练的架构，判别器损失系数为 50，大小乘数为 1/4。此外，在 ELECTRA 训练中，只要 F-TFM 被用作判别器，生成器也使用 F-TFM。
此外，在所有实验中，我们仅标注隐藏状态的大小，其余模型大小可以从中推导得出：
- 嵌入大小 = 隐藏大小
- P-FFN 的内部状态大小为“4 × 隐藏大小”
- 注意力头的维度始终为 64
- 注意力头的数量为“隐藏大小 / 64”
最后，预训练中的另一个重要因素是掩码采样策略。对于 MLM（掩码语言建模）训练，我们遵循之前的工作，始终采用完整词跨度采样（最多 5 个完整词）。然而，对于 ELECTRA 训练，我们注意到了一个奇怪的现象：在基础规模设置下，如果使用词跨度采样而不是单 token 采样，Transformer 和 F-TFM 的性能都会显著下降。另一方面，在大规模设置下，使用词跨度采样效果良好。因此，在基础规模的 ELECTRA 训练中，我们使用单 token 采样；而在大规模的 ELECTRA 训练中，我们使用词跨度采样。
B.3 微调
B.3 微调
在所有微调实验中，我们基本上继承了 XLNet [3] 使用的超参数。所有报告的性能数据均是在 TPU 上使用 TensorFlow 2.2 获得的。
B.3.1 GLUE 和文本分类
对于 GLUE 和文本分类数据集，我们首先固定表 8 中所示的大多数超参数值。然后，我们仅从集合 [1e-5, 2e-5, 3e-5] 中搜索学习率，并根据验证集选择最佳学习率。
根据之前的工作 [3, 4, 5]，所有 GLUE 性能数据对应于基础设置下 5 次不同随机种子运行的中位数结果，以及大规模设置下 15 次运行的中位数结果。
对于文本分类，基础规模的结果是 5 次不同随机种子运行的中位数性能。然而，对于大规模实验，为了与之前的工作 [34, 3] 兼容，结果是 5 次随机运行中的最佳性能。
B.3.2 阅读理解
同样，遵循 XLNet [3]，用于 RACE 和 SQuAD 数据集微调的超参数总结在表 9 中。“分层衰减”意味着以自上而下的方式指数衰减各层的学习率。例如，假设第 24 层使用学习率 l l l，分层衰减率为 α \alpha α，则第 m m m 层的学习率为 l α 24 − m l\alpha^{24-m} lα24−m。此外，对于 SQuAD 的两个版本，我们在评估 SQuAD v1.1 时直接重用了在 SQuAD v2.0 上训练的模型。
C 额外实验结果
C.1 大规模文本分类
表 10 包含了大规模训练设置下 7 个文本分类任务的性能对比。与 GLUE 基准测试结果类似，与之前基于 Transformer 的结果相比，在更少的 FLOPs 下，提出的 F-TFM 取得了可比的结果。
C.2 训练成本对比
在本节中，我们在 TPU 和 GPU 平台上测试了 F-TFM 的预训练和微调速度，并与标准 Transformer 进行了对比。对于预训练速度评估，我们在 TPU v3-16（16 核 x 16Gb）上使用 TensorFlow 测试 F-TFM。对于微调速度评估，我们在 TPU v2-8（8 核 x 8Gb）上使用 TensorFlow 和在 Nvidia-V100（16Gb）GPU 上使用 PyTorch 测试 F-TFM。TensorFlow 版本为 2.2.0，PyTorch 版本为 1.5.0。对于 GPU 实验，我们使用 Google Cloud Platform 上的一个 8-GPU 节点。所有运行速度均使用 FP16 优化器报告。在 PyTorch 实现中，我们使用 apex3 包中的 AMP 管理器的“O2”选项来处理 FP16 优化。对于微调，我们考虑了三种不同的序列长度，即 128、256 和 512。对于预训练，我们仅考虑序列长度 512。在每种情况下，我们选择设备内存允许的最大可能批量大小。我们通过使用固定长度的随机输入序列执行 1000 步梯度下降来测量实际模型运行时间。
首先，我们比较了微调阶段的模型速度。请注意，在此设置中未使用解码器。表 11 和表 12 分别总结了 GPU 和 TPU 上的微调运行时间对比。
-
在基础模型（L12H768）组中，我们观察到 B6-6-6H768 的速度与基础 Transformer 模型相似或更快，尽管 B6-6-6 更深且具有更多参数。
此外，与基础 Transformer 模型相比，B6-6-6H768 取得了更好的结果。类似的结论也适用于 B6-3x2-3x2 模型，该模型与基础模型具有相同数量的参数。B4-4-4 模型与基础模型具有相同的深度和模型参数，能够在性能损失较小的情况下提供 30%-50% 的加速。
-
在大型模型（L24H1024）组中，结论类似。B10-10-10 模型的速度几乎与大型模型相同，而 B8-8-8 模型的速度明显快于大型模型。此外，当序列长度等于 512 时，F-TFM 在 TPU 上的加速比 GPU 上更为明显。
-
在这两组中，所有测试的 F-TFM 变体都比标准 TFM 模型具有更小的内存占用，显示了 F-TFM 的内存效率。
接下来，我们在表 13 中比较了在 MLM 目标下预训练期间的模型速度，由于解码器的存在，预训练会有额外的成本。结果表明，与标准 Transformer 相比，所提出的方法仍然可以显著提高预训练速度，尽管速度增益略小于微调阶段。
总之，这项研究表明，在现代并行计算平台上，所提出的方法在微调和预训练阶段都更加高效。
