Nyströmformer: A Nyström-Based Algorithm for Approximating Self-Attention

Introduction

Transformer-based models, such as BERT (Devlin et al. 2019) and GPT-3 (Brown et al. 2020), have been very successful in natural language processing (NLP), achieving state-of-the-art performance in machine translation (Vaswani et al. 2017), natural language inference (Williams, Nangia, and Bowman 2018), paraphrasing (Dolan and Brockett 2005), text classification (Howard and Ruder 2018), question answering (Rajpurkar et al. 2016) and many other NLP tasks (Peters et al. 2018; Radford et al. 2018). A key feature of transformers is what is known as the self-attention mechanism (Vaswani et al. 2017), where each token’s representation is computed from all other tokens. Self-attention enables interactions of token pairs across the full sequence and has been shown quite effective.

Despite the foregoing advantages, self-attention also turns out to be a major efficiency bottleneck since it has a memory and time complexity of $O(n^{2})$ where $n$ is the length of an input sequence. This leads to high memory and computational requirements for training large Transformer-based models. For example, training a BERT-large model (Devlin et al. 2019) will need 4 months using a single Tesla V100 GPU (equivalent to 4 days using a 4x4 TPU pod). Further, the $O(n^{2})$ complexity makes it prohibitively expensive to train large Transformers with long sequences (e.g., $n=2048$).

To address this challenge, several recent works have proposed strategies that avoid incurring the quadratic cost when dealing with longer input sequences. For example, (Dai et al. 2019) suggests a trade-off between memory and computational efficiency. The ideas described in (Child et al. 2019; Kitaev, Kaiser, and Levskaya 2019) decrease the self-attention complexity to $O(n\sqrt{n})$ and $O(n\log n)$ respectively. In (Shen et al. 2018b; Katharopoulos et al. 2020; Wang et al. 2020), self-attention complexity can be reduced to $O(n)$ with various approximation ideas, each with its own strengths and limitations.

In this paper, we propose a $O(n)$ approximation, both in the sense of memory and time, for self-attention. Our model, Nyströmformer, scales linearly with the input sequence length $n$. This is achieved by leveraging the celebrated Nyström method, repurposed for approximating self-attention. Specifically, our NyströmFormer algorithm makes use of landmark (or Nyström) points to reconstruct the softmax matrix in self-attention, thereby avoiding computing the $n\times n$ softmax matrix. We show that this yields a good approximation of the true self-attention.

To evaluate our method, we consider a transfer learning setting using Transformers, where models are first pretrained with a language modeling objective on a large corpus, and then finetuned on target tasks using supervised data (Devlin et al. 2019; Liu et al. 2019; Lewis et al. 2020; Wang et al. 2020). Following BERT (Devlin et al. 2019; Liu et al. 2019), we pretrain our proposed model on English Wikipedia and BookCorpus (Zhu et al. 2015) using a masked-language-modeling objective. We observe a similar performance to the baseline BERT model on English Wikipedia and BookCorpus. We then finetune our pretrained models on multiple downstream tasks in the GLUE benchmark (Wang et al. 2018) and IMDB reviews (Maas et al. 2011), and compare our results to BERT in both accuracy and efficiency. Across all tasks, our model compares favorably to the vanilla pretrained BERT with significant speedups.

Finally, we evaluate our model on tasks with longer sequence lengths from the Long Range Arena (LRA) benchmark (Tay et al. 2020). NyströmFormer performs well compared to several recent efficient self-attention methods, including Reformer (Kitaev, Kaiser, and Levskaya 2019), Linformer (Wang et al. 2020), and Performer (Choromanski et al. 2020), by margin of $\sim$3.4% in average accuracy. We believe that the idea is a step towards resource efficient Transformers.

Related Work

We briefly review relevant works on efficient Transformers, linearized Softmax kernels and Nyström-like methods.

Efficient Transformers. Weight pruning (Michel, Levy, and Neubig 2019), weight factorization (Lan et al. 2020), weight quantization (Zafrir et al. 2019) or knowledge distillation (Sanh et al. 2019) are several strategies that have been proposed to improve memory efficiency in Transformers. The use of a new pretraining objective in (Clark et al. 2019), product-key attention in (Lample et al. 2019), and the Transformer-XL model in (Dai et al. 2019) have shown how the overall compute requirements can be reduced. In (Child et al. 2019), a sparse factorization of the attention matrix was used for reducing the overall complexity from quadratic to $O(n\sqrt{n})$ for generative modeling of long sequences. In (Kitaev, Kaiser, and Levskaya 2019), the Reformer model further reduced the complexity to $O(n\log n)$ via locality-sensitive-hashing (LSH). This relies on performing fewer dot product operations overall by assuming that the keys need to be identical to the queries. Recently, in (Wang et al. 2020), the Linformer model suggested the use of random projections based on the JL lemma to reduce the complexity to $O(n)$ with a linear projection step. The Longformer model in (Beltagy, Peters, and Cohan 2020) achieved a $O(n)$ complexity using a local windowed attention and a task-motivated global attention for longer documents, while BIGBIRD (Zaheer et al. 2020) used a sparse attention mechanism. There are also other existing approaches to improve optimizer efficiency, such as micro-batching (Huang et al. 2019) and gradient checkpointing (Chen et al. 2016). Concurrently with our developments, the Performer model proposed in (Choromanski et al. 2020) made use of positive orthogonal random features to approximate softmax attention kernels with $O(n)$ complexity.

Linearized Softmax. In (Blanc and Rendle 2018), an adaptive sampled softmax with a kernel based sampling was shown to speed up training. It involves sampling only some of the classes at each training step using a linear dot product approximation. In (Rawat et al. 2019), the Random Fourier Softmax (RF-softmax) idea uses random Fourier features to perform efficient sampling from an approximate softmax distribution for normalized embedding. In (Shen et al. 2018b; Katharopoulos et al. 2020), linearizing the softmax attention in transformers was based on heuristically separating keys and queries in a linear dot product approximation. While the idea is interesting, the approximation error to the softmax matrix in self-attention can be large in some cases. The lambda layers in (Bello 2021), can also be thought of as an efficient relative attention mechanism.

Nyström-like methods. Nyström-like methods sample columns of the matrix to achieve a close approximation to the original matrix. The Nyström method (Baker 1977) was developed as a way of discretizing an integral equation with a simple quadrature rule and remains a widely used approach for approximating the kernel matrix with a given sampled subset of columns (Williams and Seeger 2001). Many variants such as Nyström with $k$-means (Zhang, Tsang, and Kwok 2008; Zhang and Kwok 2010), randomized Nyström (Li, Kwok, and Lü 2010), Nyström with spectral shift (Wang et al. 2014), Nyström with pseudo landmarks, prototype method (Wang and Zhang 2013; Wang, Zhang, and Zhang 2016), fast-Nys (Si, Hsieh, and Dhillon 2016), and MEKA (Si, Hsieh, and Dhillon 2017), ensemble Nyström (Kumar, Mohri, and Talwalkar 2009) have been proposed for specific improvements over the basic Nyström approximation. In (Nemtsov, Averbuch, and Schclar 2016), the Nyström method was extended to deal with a general matrix (rather than a symmetric matrix). The authors in (Musco and Musco 2017) introduced the RLS-Nyström method, which proposes a recursive sampling approach to accelerate landmark points sampling. (Fanuel, Schreurs, and Suykens 2019) developed DAS (Deterministic Adaptive Sampling) and RAS (Randomized Adaptive Sampling) algorithms to promote diversity of landmarks selection.

The most related ideas to our development are (Wang and Zhang 2013; Musco and Musco 2017). These approaches are designed for general matrix approximation (which accurately reflects our setup) while only sampling a subset of columns and rows. However, directly applying these methods to approximate a softmax matrix used by self-attention does not directly reduce the computational complexity. This is because that even accessing a subset of columns or rows of a softmax matrix will require the calculation of all elements in the full matrix before the softmax function. And calculating these entries will incur a quadratic cost. Nonetheless, inspired by the key idea of using a subset of columns to reconstruct the full matrix, we propose a Nyström approximation with $O(n)$ complexity tailored for the softmax matrix, for approximating self-attention efficiently.

Nyström-Based Linear Transformers

In this section, we start by briefly reviewing self-attention, then discuss the basic idea of Nyström approximation method for the softmax matrix in self-attention, and finally adapting this idea to achieve our proposed construction.

What is self-attention? Self-attention calculates a weighted average of feature representations with the weight proportional to a similarity score between pairs of representations. Formally, an input sequence of $n$ tokens of dimensions $d$, $X\in\textbf{R}^{n\times d}$, is projected using three matrices $W_{Q}\in\textbf{R}^{d\times d_{q}}$, $W_{K}\in\textbf{R}^{d\times d_{k}}$, and $W_{V}\in\textbf{R}^{d\times d_{v}}$ to extract feature representations $Q$, $K$, and $V$, referred to as query, key, and value respectively with $d_{k}=d_{q}$. The outputs $Q$, $K$, $V$ are computed as

where softmax denotes a row-wise softmax normalization function. Thus, each element in the softmax matrix $S$ depends on all other elements in the same row.

Compute cost of self-attention. The self-attention mechanism requires calculating $n^{2}$ similarity scores between each pair of tokens, leading to a complexity of $O(n^{2})$ for both memory and time. Due to this quadratic dependence on the input length, the application of self-attention is limited to short sequences (e.g., $n<1000$). This is a key motivation for a resource-efficient self-attention module.

Nyström Method for Matrix Approximation

The starting point of our work is to reduce the computational cost of self-attention in Transformers using the Nyström method, widely adopted for matrix approximation (Williams and Seeger 2001; Drineas and Mahoney 2005; Wang and Zhang 2013). Following (Wang and Zhang 2013), we describe a potential strategy and its challenges for using the Nyström method to approximate the softmax matrix in self-attention by sampling a subset of columns and rows.

Denote the softmax matrix used in self-attention $S=\text{softmax}\left(\frac{QK^{T}}{\sqrt{d_{q}}}\right)\in\textbf{R}^{n\times n}$. $S$ can be written as

where $A_{S}\in\textbf{R}^{m\times m},B_{S}\in\textbf{R}^{m\times(n-m)},F_{S}\in\textbf{R}^{(n-m)\times m}$ and $C_{S}\in\textbf{R}^{(n-m)\times(n-m)}$. $A_{S}$ is designated to be our sample matrix by sampling $m$ columns and rows from $S$.

Quadrature technique. $S$ can be approximated via the basic quadrature technique of the Nyström method. It begins with the singular value decomposition (SVD) of the sample matrix, $A_{S}=U\Lambda V^{T}$, where $U,V\in\textbf{R}^{m\times m}$ are orthogonal matrices, $\Lambda\in\textbf{R}^{m\times m}$ is a diagonal matrix. Based on the out-of-sample columns approximation (Wang and Zhang 2013), the explicit Nyström form of $S$ can be reconstructed with $m$ columns and $m$ rows from $S$,

where $A_{S}^{+}$ is the Moore-Penrose inverse of $A_{S}$. $C_{S}$ is approximated by $F_{S}A_{S}^{+}B_{S}$. Here, (4) suggests that the $n\times n$ matrix $S$ can be reconstructed by sampling $m$ rows ($A_{S},B_{S}$) and $m$ columns ($A_{S},F_{S}$) from $S$ and finding the Nyström approximation $\hat{S}$.

Nyström approximation for softmax matrix. We briefly discuss how to construct the out-of-sample approximation for the softmax matrix in self-attention using the standard Nyström method. Given a query $q_{i}$ and key $k_{j}$, let

where $\mathcal{K}_{K}(q_{i})\in\textbf{R}^{1\times n}$ and $\mathcal{K}_{Q}(k_{j})\in\textbf{R}^{n\times 1}$. We can then construct

where $[\cdot]_{m\times 1}$ refers to calculating the full $n\times 1$ vector and then taking the first $m\times 1$ entries. With $\phi_{K}(q_{i})$ and $\phi_{Q}(k_{j})$ available in hand, the entry of $\hat{S}$ for standard Nyström approximation is calculated as,

In matrix form, $\hat{S}$ can be represented as,

where $\left[\cdot\right]_{n\times m}$ refers to taking $m$ columns from $n\times n$ matrix and $\left[\cdot\right]_{m\times n}$ refers to taking $m$ rows from $n\times n$ matrix. This representation is the application of (4) for softmax matrix approximation in self-attention. $\begin{bmatrix}A_{S}\\ F_{S}\end{bmatrix}$ in (4) corresponds to the first $n\times m$ matrix in (6) and $\begin{bmatrix}A_{S}\quad B_{S}\end{bmatrix}$ in (4) corresponds to the last $n\times m$ matrix in (6). More details of the matrix representation is available in the supplement.

A key challenge of Nyström approximation. Unfortunately, (4) and (6) require calculating all entries in $QK^{T}$ due to the softmax function, even though the approximation only needs to access a subset of the columns of $S$, i.e., $\begin{bmatrix}A_{S}\\ F_{S}\end{bmatrix}$. The problem arises due to the denominator within the row-wise softmax function. Specifically, computing an element in $S$ requires a summation of the exponential of all elements in the same row of $QK^{T}$. Thus, calculating $\begin{bmatrix}A_{S}\\ F_{S}\end{bmatrix}$ needs accessing the full $QK^{T}$, shown in Fig. 1, and directly applying Nyström approximation as in (4) is not attractive.

Linearized Self-Attention via Nyström Method

In the description that follows, we first define the matrix form of landmarks. Then, based on the landmarks matrix, we form the three matrices needed for our approximation.

The corresponding $m\times m$ matrix is generated by

Note that in the SVD decomposition of $A_{S}$, $U_{m\times m}$ and $V_{m\times m}$ are orthogonal matrices.

Similar to the out-of-sample approximation procedure for the standard Nyström scheme described above, given a query $q_{i}$ and key $k_{j}$, let

Let $W_{m}=V_{m\times m}\Lambda^{-1}_{m\times m}U_{m\times m}^{T}$. Recall that a SVD of $A_{S}$ is $U_{m\times m}\Lambda_{m\times m}V_{m\times m}^{T}$, and so, $W_{m}A_{S}=I_{m\times m}$. Therefore,

Based on (10), we can rewrite it to have a similar form as (4) (i.e., not requiring that $A_{S}$ is non-singular) as

where $A_{S}^{+}$ is a Moore-Penrose pseudoinverse of $A_{S}$. So,

for $i,j=\{1,\dots,n\}$. The Nyström form of the softmax matrix, $S=\text{softmax}\left(\frac{QK^{T}}{\sqrt{d_{q}}}\right)$ is thus approximated as

Note that we arrive at (13) via an out-of-sample approximation similar to (4). The difference is that in (13), the landmarks are selected before the softmax operation to generate the out-of-sample approximation. This is a compromise but avoids the need to compute the full softmax matrix $S$ for a Nyström approximation. Fig. 2 illustrates the proposed Nyström approximation and Alg. 1 summarizes our method.

We now describe (a) the calculation of the Moore-Penrose inverse and (b) the selection of landmarks.

Moore-Penrose inverse computation. Moore-Penrose pseudoinverse can be calculated by using singular value decomposition. However, SVD is not very efficient on GPUs. To accelerate the computation, we use an iterative method from (Razavi et al. 2014) to approximate the Moore-Penrose inverse via efficient matrix-matrix multiplications.

For $A_{S}\in\textbf{R}^{m\times m}$, the sequence $\{Z_{j}\}_{j=0}^{j=\infty}$ generated by (Razavi et al. 2014),

converges to the Moore-Penrose inverse $A_{S}^{+}$ in the third-order with initial approximation $Z_{0}$ satisfying $||A_{S}A_{S}^{+}-A_{S}Z_{0}||<1$.

We select $Z_{0}$ by $Z_{0}=\nicefrac{{A_{S}^{T}}}{{(||A_{S}||_{1}||A_{S}||_{\infty})}}$ where

based on (Pan and Schreiber 1991). This choice ensures that $||I-A_{S}Z_{0}||_{2}<1$. When $A_{S}$ is non-singular,

Without the non-singular constraint, the choice of initializing $Z_{0}$ provides a good approximation in our experiments. For all our experiments, we need to run about $6$ iterations in order to achieve a good approximation of the pseudoinverse.

Let $A_{S}^{+}$ be approximated by $Z^{\star}$ with (14). Our Nyström approximation of $S$ can be written as

Here, (15) only needs matrix-matrix multiplications, thus the gradient computation is straight-forward.

Landmarks selection. Landmark points (inducing points (Lee et al. 2019)) can be selected by using K-means clustering (Zhang, Tsang, and Kwok 2008; Vyas, Katharopoulos, and Fleuret 2020). However, the EM style of updates in K-means is less desirable during mini-batch training. We propose to simply use Segment-means similar to the local average pooling previously used in the NLP literature (Shen et al. 2018a). Specifically, for input queries $Q=[q_{1};\dots;q_{n}]$, we separate the $n$ queries into $m$ segments. As we can pad inputs to a length divisible to $m$, we assume $n$ is divisible by $m$ for simplicity. Let $l=\nicefrac{{n}}{{m}}$, landmark points for $Q$ are calculated as shown in (16). Similarly, for input keys $K=[k_{1};\dots;k_{n}]$, landmarks are computed as shown below in (16).

where $j=1,\cdots,m$. Segment-means requires a single scan of the sequence to compute the landmarks leading to a complexity of $O(n)$. We find that using $64$ landmarks is often sufficient to ensure a good approximation, although this depends on the application. More details regarding the landmark selection is provided in the supplement.

Approximate self-attention. With landmark points and pseudoinverse computed, the Nyström approximation of the softmax matrix can be calculated. By plugging in the Nyström approximation, we obtain a linearized version $\hat{S}V$, to approximate the true self-attention $SV$,

Fig. 3 presents an example of the fidelity between Nyström approximate self-attention versus true self-attention.

Analysis of Nyström Approximation

Lemma 2 suggests that if the landmark points overlap sufficiently with the original data points, the approximation to self-attention will be good. While the condition here is problem dependent, we note that it is feasible to achieve an accurate approximation without using a large number of landmarks. This is because (Oglic and Gärtner 2017) points out that the error of Nyström approximation depends on the spectrum of the matrix to be approximated and it decreases with the rank of the matrix. When this result is compared with the observation in (Wang et al. 2020) where the authors suggest that self-attention is low-rank, stronger guarantees based on structural properties of the matrix that we wish to approximate are possible.

Our Model: Nyströmformer

Experiments

We now present our experiments and results. Our experiments follow a transfer learning setting that consists of two stages. In the first stage, we train Nyströmformer on a large-scale text corpus, and report the language modeling performance of our model on a hold-out validation set. In the second stage, we fine-tune the pre-trained Nyströmformer across several different NLP tasks in GLUE benchmarks (Wang et al. 2019) and IMDB reviews (Maas et al. 2011), and report the performance on individual dataset for each task. In both stages, we compare our results to a baseline Transformer model (BERT). In addition to language modeling, we also conduct experiments on long range context tasks in the Long Range Arena (LRA) benchmark.

Our first experiment evaluates if our model can achieve similar performance with reduced complexity compared to a standard Transformer on language modeling. We introduce the dataset and evaluation protocol, describe implementation details, and finally present the results of our model.

Dataset and metrics. We consider BookCorpus plus English Wikipedia as the training corpus, which is further split into training (80%) and validation (20%) sets. Our model is trained using the training set. We report the masked-language-modeling (MLM) and sentence-order-prediction (SOP) accuracy on the validation set, and compare the efficiency (runtime/memory) to a baseline.

Baselines. Our baseline is the well-known Transformer based model – BERT (Devlin et al. 2019). Specifically, we consider two variants of BERT:

BERT-small is a light weighted BERT model with 4 layers. We use BERT-small to compare to linear Transformers, including ELU linearized self-attention (Katharopoulos et al. 2020) and Linformer (Wang et al. 2020).

BERT-base is the base model from (Devlin et al. 2019). We use this model as our baseline when fine-tuning on downstream NLP tasks.

Our Nyströmformer replaces the self-attention in BERT-small and BERT-base using the proposed Nyström approximation. We acknowledge that several very recent articles (Zaheer et al. 2020; Beltagy, Peters, and Cohan 2020), concurrent with our work, have also proposed efficient $O(n)$ self-attention for Transformers. An exhaustive comparison to a rapidly growing set of algorithms is prohibitive unless extensive compute resources are freely available. Thus, we only compare runtime performance and the memory consumption of our method to Linformer (Wang et al. 2020) and Longformer (Beltagy, Peters, and Cohan 2020) in Table 1.

Implementation details. Our model is pre-trained with the masked-language-modeling (MLM) and sentence-order-prediction (SOP) objectives (Lan et al. 2020). We use a batch size of 256, Adam optimizer with learning rate 1e-4, $\beta_{1}=0.9$, $\beta_{2}=0.999$, L2 weight decay of $0.01$, learning rate warm-up over the first 10,000 steps, and linear learning rate decay to update our model. Training BERT-base with $1$M update steps takes more than one week on 8 V100 GPUs. To keep compute costs reasonable, our baseline (BERT-base) and our model are trained with 0.5M steps. We also train our model with $\sim$0.25M steps, initialized from pre-trained BERT-base for speed-up. For BERT-small, we train for $0.1$M steps. More details are in the supplement.

Results on accuracy and efficiency. We report the validation accuracy and inference efficiency of our model and compare the results to transformer based models. In Fig. 5 and 6, we plot MLM and SOP pre-training validation accuracy, which shows that Nyströformer is comparable to a standard transformer and outperforms other variants of efficient transformers. We also note the computation and memory efficiency of our model in Table 1. To evaluate the inference time and memory efficiency, we generate random inputs for self-attention module with sequence length $n\in$. All models are evaluated on the same machine setting with a Nvidia 1080Ti and we report the improved inference speed and memory savings.

Fine-tuning on Downstream NLP tasks

Our second experiment is designed to test the generalization ability of our model on downstream NLP tasks. To this end, we fine-tune the pretrained model across several NLP tasks.

Datasets and metrics. We consider the datasets of SST-2 (Socher et al. 2013), MRPC (Dolan and Brockett 2005), QNLI (Rajpurkar et al. 2016), QQP (Chen et al. 2018), and MNLI (Williams, Nangia, and Bowman 2018) in GLUE benchmark and IMDB reviews (Maas et al. 2011). We follow the standard evaluation protocols, fine-tune the pre-trained model on the training set, report the results on the validation set, and compare them to our baseline BERT-base.

Implementation details. We fine-tune our pre-trained model on GLUE benchmark datasets and IMDB reviews respectively and report its final performance. For larger datasets (SST-2, QNLI, QQP, MMNL, IMDB reviews), we use a batch size of 32 and the AdamW optimizer with learning rate 3e-5 and fine-tune our models for 4 epochs. For MRPC, due to the sensitivity of a smaller dataset, we follow (Devlin et al. 2019) by performing a hyperparameter search with candidate batch size $[$8, 16, 32$]$ and learning rate $[$2e-5, 3e-5, 4e-5, 5e-5$]$, and select the best validation result. As these downstream tasks do not exceed the maximum input sequence length 512, we fine-tune our model trained on an input sequence length of 512.

Results. Table 2 presents our experimental results on natural language understanding benchmarks with different tasks. Our results compares favorably to BERT-base across all downstream tasks. Further, we also experiment with fine-tuning our model using longer sequences ($n=1024$), yet the results remain almost identical to $n=512$, e.g. 93.0 vs. 93.2 accuracy on IMDB reviews. These results suggest that our model is able to scale linearly with input length. Additional details on longer sequences is in the supplement.

Long Range Arena (LRA) Benchmark

Our last experiment evaluates our model on tasks with longer sequence lengths. We follow the LRA benchmark (Tay et al. 2020) and compare our method against other efficient self-attention variants.

Datasets and metrics. We consider the LRA benchmark (Tay et al. 2020) with tasks of Listops (Nangia and Bowman 2018), byte-level IMDb reviews text classification (Maas et al. 2011), byte-level document retrieval (Radev et al. 2013), image classification on sequences of pixels (Krizhevsky, Hinton et al. 2009), and Pathfinder (Linsley et al. 2018). We follow the evaluation protocol from (Tay et al. 2020), including the train/test splits, and report the classification accuracy for each task, as well as the average accuracy across all tasks.

Baselines. We compare different self-attention methods using a same Transformer model. Our baselines consist of the vanilla self-attention (Vaswani et al. 2017), and several recent efficient self-attention variants, including Reformer (Kitaev, Kaiser, and Levskaya 2019), Linformer (Wang et al. 2020), and Performer (Choromanski et al. 2020).

Implementation details. The official LRA benchmark (Tay et al. 2020) is implemented in Jax/Flax (Frostig, Johnson, and Leary 2018). To achieve a fair comparison to our baselines implemented in PyTorch, we reimplemented the benchmark in PyTorch and verified the results. All our experiments, including our method and all baselines, use a Transformer model with 2 layers, 64 embedding dimension, 128 hidden dimension, 2 attention heads. Mean pooling is used for all tasks. The number of hashes for Reformer is 2, the projection dimension for Linformer is 256, and random feature dimension for Performer is 256.

Results. Table 3 compares our method to baselines. Our results are on par with the vanilla self-attention for all tasks, with comparable average accuracy (+0.18%) but are more efficient (see Table 1). Importantly, our method outperforms other efficient self-attention methods, with +3.91%, +3.36%, +5.32% in average accuracy against Reformer, Linformer, and Performer, respectively. We find that the model behaves favorably relative to the concurrent work of Performer across all tasks, and in general, provides a good approximation to self-attention for longer sequences.

Conclusion

Scaling Transformer based models to longer sequences is desirable in both NLP as well as computer vision, and it will involve identifying ways to mitigate its compute and memory requirements. Within the last year, this need has led to a number of results describing how randomized numerical linear algebra schemes based on random projections and low rank assumptions can help (Katharopoulos et al. 2020; Wang et al. 2020; Beltagy, Peters, and Cohan 2020; Zaheer et al. 2020). Here, we approach this task differently by showing how the Nyström method, a widely used strategy for matrix approximation, can be adapted and deployed within a deep Transformer architecture to provide an efficient approximation of self attention. We show that our design choices and modifications enable all key operations to be mapped to popular deep learning libraries conveniently. The algorithm maintains the performance profile of other self-attention approximations in the literature but offers additional benefit of resource utilization, and is a step towards building Transformer models on very long sequences. Our code/supp is available at https://github.com/mlpen/Nystromformer.

Acknowledgments. This work was supported in part by a American Family Insurance grant via American Family Insurance Data Science Institute at UW, NSF CAREER award RI 1252725 and UW CPCP (U54AI117924). We thank Denny Zhou, Hongkun Yu, and Adam Yu for valuable discussions. The paper also benefited from comments regarding typos and suggestions pointed out by Yannic Kilcher, Sebastian Bodenstein and Github user thomasw21. We thank Phil Wang and Lekton Zhang for making their implementation available at https://github.com/lucidrains/nystrom-attention.

References