Year: 2022

Abstract:
Transformer has shown great successes in natural language processing, computer vision, and audio processing. As one of its core components, the softmax attention helps to capture long-range dependencies yet prohibits its scale-up due to the quadratic space and time complexity to the sequence length. Kernel methods are often adopted to reduce the complexity by approximating the softmax operator. Nevertheless, due to the approximation errors, their performances vary in different tasks/corpus and suffer crucial performance drops when compared with the vanilla softmax attention. In this paper, we propose a linear transformer called COSFORMER that can achieve comparable or better accuracy to the vanilla transformer in both casual and cross attentions. COSFORMER is based on two key properties of softmax attention: i). non-negativeness of the attention matrix; ii). a non-linear re-weighting scheme that can concentrate the distribution of the attention matrix. As its linear substitute, COSFORMER fulfills these properties with a linear operator and a cosine-based distance re-weighting mechanism. Extensive experiments on language modeling and text understanding tasks demonstrate the effectiveness of our method. We further examine our method on long sequences and achieve state-of-the-art performance on the Long-Range Arena benchmark. The source code is available at COSFORMER .

heading: 1 INTRODUCTION
text: With years of development, the transformer model (Vaswani et al., 2017) and its variants (Zaheer et al., 2020; Wang et al., 2020; Tay et al., 2020a) have been successfully adapted to three most popular artificial intelligence (AI) fields: i.e., natural language processing (Devlin et al., 2019; Liu et al., 2019), computer vision (Dosovitskiy et al., 2020; Carion et al., 2020; Liu et al., 2021) and audio processing (Schneider et al., 2019; Baevski et al., 2020). Compared with conventional
∗Indicates the corresponding author. † Indicates equal contribution.
recurrent (Hochreiter & Schmidhuber, 1997) and convolutional architectures (He et al., 2016), transformer-based architectures are generally more scalable to data volumes (Brown et al., 2020) and stronger in capturing global information with less inductive bias, thus excelling on many tasks.
Dot-product attention with softmax normalization is the cornerstone of the transformer to capture long-range dependencies. However, its quadratic space and time complexity with regard to the length of the sequence make its computational overhead prohibitive, especially for long inputs. To address this issue, numerous methods are proposed recently, such as the sparse attention matrix (Zaheer et al., 2020; Beltagy et al., 2020; Tay et al., 2020a; Kitaev et al., 2019; Child et al., 2019),lowrank representations (Wang et al., 2020) or kernel-based methods (Peng et al., 2020; Choromanski et al., 2020; Katharopoulos et al., 2020), among many others. These methods achieve reduced computational complexity with comparable performances when compared with the vanilla attention architecture on several selected tasks or corpus.
However, the improved efficiency is usually achieved via introducing additional yet often impractical assumptions on the attention matrix (Wang et al., 2020) or with valid approximation of softmax operation only within constrained theoretical bounds (Choromanski et al., 2020; Peng et al., 2020) Therefore, when their assumptions are unsatisfied or when approximation errors get accumulated, these methods may not always be advantageous over the vanilla architecture (Narang et al., 2021). Consequently, performance deficiencies in a broad application spectrum are often observed in these transformer variants, especially those with linear complexity. For example, the Performer (Choromanski et al., 2020), RFA (Peng et al., 2020) and Reformer (Kitaev et al., 2019) show less satisfactory performance on the GLUE benchmark (Wang et al., 2018) when compared with the vanilla architecture as suggested in our preliminary experiments (Tab. 2). Furthermore, many of these aforementioned methods are not applicable to casual attentions, which are critical for auto-regressive training. For example, techniques proposed in Linformer (Wang et al., 2020) and BigBird (Zaheer et al., 2020) are specific to cross attentions.
Since the softmax operator appears to be the main hurdle while efficient yet accurate approximation to softmax is difficult to achieve, one question naturally arises: “Can we replace the softmax operator with a linear function instead, while maintaining its key properties?”. By digging into the softmax attention, we find two key properties that affect its empirical performance: (i) elements in the attention matrix are non-negative (Tsai et al., 2019; Katharopoulos et al., 2020); (ii) the non-linear re-weighting scheme acts as a stabilizer for the attention weights (Titsias, 2016; Gao & Pavel, 2017; Jang et al., 2016). These findings reveal some new insights of the current approaches. For example, the linear transformer (Katharopoulos et al., 2020) achieves property (i) using an exponential linear unit (Clevert et al., 2016) activation function. However, due to lack of the re-weighting scheme, it underperforms other efficient transformer variants on the Long-Range Arena benchmark as shown in Figure 1 as well as the language modeling task (Table 2) based on our controlled experiments.
In this paper, we propose a new variant of linear transformer called COSFORMER that satisfies both of the above properties. Specifically, we enforce the non-negative property by passing the features to a ReLU (Agarap, 2018) activation function before computing the similarity scores. In this way, we encourage the model to avoid aggregating negatively-correlated contextual information. Further, we adopt a cos re-weighting scheme to stabilize the attention weights. This helps the model to amplify local correlations, which usually contain more relevant information for natural language tasks. Thanks to the Ptolemy’s theorem, our attention can be exactly decomposed into a linear form. We perform extensive experiments on both autoregressive language models and bidirectional models on five public benchmarks, including WikiText-103 (Merity et al., 2017), GLUE (Wang et al., 2018), IMDB (Maas et al., 2011), AMAZON (Ni et al., 2019) and Long-Range Arena benchmark (Tay et al., 2020b). Our model shows much better inference speed and smaller memory footprint, while achieving on par performance with the vanilla transformer. It is noteworthy that our method ranks 1st on the Long-Range Arena benchmark, showing favorable performance than other competitors, which well demonstrates its strong capacity in modeling long sequence inputs.

heading: 2 OUR METHOD
text: In this section, we provide technique details of our linear transformer called COSFORMER . The key insight of the COSFORMER is to replace the non-decomposable non-linear softmax operation by a linear operation with decomposable non-linear re-weighting mechanism. Our model is applicable
to both casual and cross attentions with a linear time and space complexity with regard to the input sequence length, thus exhibiting strong capacity in modeling long-range dependencies.

heading: 2.1 THE GENERAL FORM OF TRANSFORMER
text: Given an input sequence x with length of N , we first represent it in the embedding space x ∈ RN×d with feature dimension of d. A transformer block T : RN×d → RN×d with input x is defined as:
T (x) = F(A(x) + x), (1)
where F is a feedforward network that contains a residual connection; A is the self-attention function that computes the attention matrix A, which has quadratic space and time complexity with respect to N , thus becoming the computation bottleneck of T on long inputs. There are three key components in A, namely, query (Q), key (K), value (V ) computed through three learnable linear matrices WQ,WK ,WV : Q = xWQ,K = xWK , V = xWV . We use Mi to represent the i-th row of a matrix M , then the output O ∈ RN×d of A(x) can be computed as:
O = A(x) = [O1, . . . ,ON ]T , Oi = ∑ j S(Qi,Kj)∑ j S(Qi,Kj) Vj , (2)
where S(·) measures the similarity between queries. If S(Q,K) = exp(QKT ), the Eq. 2 becomes the dot-product attention with softmax normalization. In this case, the space and time complexity to compute one row of the output Oi is O(N). Therefore, the total space and time complexity for computing O grows quadratically with respect to the input length.

heading: 2.2 LINEARIZATION OF SELF-ATTENTION
text: According to Eq. 2, we can select any similarity functions to compute the attention matrix. In order to maintain a linear computation budget, one solution is to adopt a decomposable similarity function such that: S(Qi,Kj) = φ(Qi)φ(Kj)T , (3) where φ is a kernel function that maps the queries and keys to their hidden representations. Then one can rewrite Eq. 2 in the form of kernel functions as:
Oi = ∑N j=1(φ(Qi)φ(Kj) T )Vj∑N
j=1(φ(Qi)φ(Kj) T )
., (4)
After that, attention operation in linear complexity is achieved via the matrix product property:
(φ(Q)φ(K)T )V = φ(Q)(φ(K)TV ). (5)
In this form (Eq. 5), instead of explicitly computing the attention matrix A = QKT ∈ RN×N , we calculate the φ(K)TV ∈ Rd×d first, and then multiplying φ(Q) ∈ RN×d. By using this trick, we only incurs a computation complexity of O(Nd2). Note that in typical natural language tasks, the feature dimension of one head d is always much smaller than the input sequence lengthN (d N ), so we can safely omit d and achieve computation complexity of O(N), as illustrated in Figure 2.
Previous Solutions As aforementioned, the key to the linear attentions is to find a decomposable similarity function S(·) that generalizes well to different tasks. Most existing linear transformers are trying to find an unbiased estimation of the softmax attention. For example, RFA (Peng et al., 2020) approximates the softmax operation with random feature maps using theorem of random fourier features (Rahimi & Recht, 2008) and the Performer (Choromanski et al., 2020) utilizes positive random features to approximate it. However, we empirically find that these methods are sensitive to the selection of sampling rate and becomes unstable if the sampling rate gets too high. Also, to accommodate recency bias, gating mechanisms are employed to better exploit more recent context.
Another group of works attempt to directly replace the softmax with a linear operation. For example, the linear transformer (Katharopoulos et al., 2020) model replaces the softmax similarity function with a pure dot product S = QKT , and use a non-linear activation function φ(·) = elu(·) + 1 to model the pairwise relation between features. However, our controlled experiments show that their solution does not necessarily generalize well on many downstream tasks (Tab. 2) or the Long-Range Arena benchmark (Tab. 4). In this paper, we propose a new replacement of softmax that not only achieves comparable or better performance than the softmax attention in a wide range of tasks, but also enjoys linear space and time complexity.
d x d
Q’ K’T V
O(Nd2)
O(Nd2 + Nd2) ≈ O(N)
O(Nd2)
N x N
Q KT V
d x NN x d
O(N2d)
O(N2d + N2d) ≈O(N2)
Softmax
O(N2d)
Vanilla self attention Linearized self attention
N x d N x d N x d d x N N x d N x d
Figure 2: Illustration of the computations for vanilla self attention (left) and linearized attention (right). The input length is N and feature dimension is d, with d N . Tensors in the same box are associated for computation. The linearized formulation allows O(N) time and space complexity.

heading: 2.3 ANALYSIS OF SOFTMAX ATTENTION
text: In the vanilla transformer architecture, when S(Q,K) = exp(QKT ), the softmax operation is applied to obtain row-wise normalization on the attention matrix A ∈ RN×N as shown in the Eq. 2. In other words, we normalize the relations of each element in the input sequence to all other elements in order to obtain a weighted aggregation of contextual information. However, apart from the good empirical performance of softmax attention, what are the crucial and necessary characteristics of it remain only loosely determined in the original transformer paper and follow-up works.
Table 1: Analysis of the softmax properties. All attention variants are implemented in the RoBERTa (Liu et al., 2019) architecture and are pre-trained on the WikiText-103 (Merity et al., 2017) dataset. The Loss represents the validation loss. We then fine-tune these variants on each downstream datasets and show the accuracy (the higher the better).
Loss QQP SST-2 MNLI φI 2.343 84.23 76.26 58.27 φLeakyReLU 2.246 84.46 78.21 74.26
φReLU 1.993 88.86 89.90 77.86 softmax 1.915 88.41 92.31 79.15
In this work, we empirically identify two key properties of the softmax operation that may play important roles for its performance: 1) it ensures all values in the attention matrix A to be non-negative; 2) it provides a non-linear reweighting mechanism to concentrates the distribution of attention connections and stabilizes the training(Titsias, 2016; Gao & Pavel, 2017; Jang et al., 2016).
To validate these assumptions, we design the following preliminary studies as shown in Table 1. First, to validate the importance of nonnegativity, we compare three instantiations of the function φ in equation 3: an identify mapping φI = I that does not preserve the non-negativity, and the other variant φReLU(·) = ReLU(·) that retains only positive input values while replacing negative values to zeros. We also add the φLeakyReLU(·) = LeakyReLU(·) variant as it does not have the non-negativity as well but have the same non-linearly as the ReLU one. Second, to demonstrate the effect of non-linear re-weighting, we compare the models using only φReLU(·) without any re-weighting and those with softmax operations. From Table 1, the superior results of φReLU over φI and φLeakyReLU demonstrate the benefit of retaining non-negative values. Our conjecture is that by retaining only positive values in the similarity matrices, the model ignores features with negative correlations, thus effectively avoiding aggregating irrelevant contextual information. By comparing the results of φReLU with the softmax, we observe that models with softmax re-weighting converge faster and generalize better to downstream tasks. This might be explained as softmax normalization amplifies the correlated pairs, which might be useful to identify useful patterns.

heading: 2.4 COSFORMER
text: Based on the observations above, we propose our model COSFORMER , which discards entirely the softmax normalization while still features the non-negativity and re-weighting mechanism. Our COSFORMER consists two main components: a linear projection kernel φlinear and a cos-Based Reweighting mechanism. Below we describe details of each components:
Linear projection kernel φlinear Recall the general form of the attention in Eq. 2, let us define a linear similarity as:
S(Q,K) = s(φlinear(Q), φlinear(K)) = s(Q ′ ,K ′ ) (6)
where φlinear is the transformation function that map queries Q and keys K to our desired representations Q ′ and K ′ , and s is a function that can be linearly decomposed to measure the similarity between Q ′ and K ′ . Specifically, in order to ensure a full positive attention matrix A and avoid
aggregating negatively-correlated information, we adopt ReLU(·) as the transformation functions and therefore effectively eliminate negative values:
φlinear(x) = ReLU(x) (7)
As Q ′ and K ′
contain only non-negative values, we directly take their dot-product s(x, y) = xyT , x, y ∈ R1×d followed by a row-wise normalization to compute attention matrices:
Oi = ∑N
j=1 f(φlinear(Qi),φlinear(Kj))Vj∑N j=1 f(φlinear(Qi),φlinear(Kj))
= ∑N j=1(ReLU(Qi)ReLU(Kj) T )Vj∑N
j=1(ReLU(Qi)ReLU(Kj) T )
(8)
Based on Eq. 4, we rearrange the order of dot-product and obtain the formulation of the proposed attention in linear complexity as:
Oi = ReLU(Qi)
∑N j=1 ReLU(Kj) TVj
ReLU(Qi) ∑N j=1 ReLU(Kj) T (9)
cos-Based Re-weighting Mechanism The non-linear re-weighting mechanism introduced by the softmax attention can concentrate the distribution of the attention weights and therefore stabilize the training process (Titsias, 2016; Gao & Pavel, 2017; Jang et al., 2016). We also empirically find that it can punish far-away connections and enforce locality in some cases. In fact, such locality bias, i.e., a large portion of contextual dependencies are from neighboring tokens, is commonly observed on downstream NLP tasks (Clark et al., 2019; Kovaleva et al., 2019), as shown in Figure 3 (1).
Based on the assumption above, what we need to fulfill the second property of softmax may be a decomposable re-weighting mechanism that can introduce recency bias to the attention matrix. Here, we propose a cos-based re-weighting mechanism as it perfectly fit our purpose: 1). the Ptolemy’s theorem ensures the cos weights can be decomposed into two summations; 2). as shown in Figure 3 (4), the cos will put more weights on the neighbouring tokens and therefore enforces locality. Also, by comparing the attention matrices in Figure 3 (2) and (3), the COSFORMER enforces more locality than the one without the re-weighting mechanism.
Specifically, by combining with Eq 6, the model with cosine re-weighting is defined as:
s(Q ′ i,K ′ j) = Q ′ iK ′T j cos ( π 2 × i−j M ) (10)
By leveraging the Ptolemy’s theorem, we decompose this formulation as:
Q ′ iK ′T j cos
( π
2 × i− j M
) = Q ′ iK ′T j ( cos ( πi
2M
) cos ( πj
2M
) + sin ( πi
2M
) sin ( πj
2M )) = ( Q ′ i cos ( πi
2M
))( K ′ j cos ( πj
2M
))T + ( Q ′ i sin ( πi
2M
))( K ′ j sin ( πj
2M ))T where i, j = 1, ..., N,M ≥ N , and Q′ = ReLU(Q),K ′ = ReLU(K). Let Qcosi = Q ′ i cos ( πi 2M ) , Qsini = Q ′ i sin ( πi 2M ) , Kcosj = K ′ j cos ( πj 2M ) , Ksinj = K ′ j sin ( πj 2M ) , the output of the proposed attention module can be expressed as:
Oi = ∑N j=1 f(Q ′ i,K ′ j)Vj∑N
j=1 f(Q ′ i,K ′ j)
=
∑N j=1Q cos i ( (Kcosj ) T Vj ) + ∑N j=1Q sin i ( (Ksinj ) T Vj )
∑N j=1Q cos i (Kcosj ) T + ∑N j=1Q sin i (Ksinj ) T , (11)
where Oi is the output at the ith position of the sequence from the attention module. Detailed derivation are included in the Appendix. Without losing the generality, our method achieves a linear complexity as:
O = S(Q,K)V = (QcosKcos +QsinKsin)V = Qcos(KcosV ) +Qsin(KsinV ) (12)
Relation to positional encoding. COSFORMER can be seen as a new way of introducing the relative positional bias to the efficient transformer. Compared with the Rotary Position Embedding (Su et al., 2021), they use a more complex position embedding strategy and did not enforce the nonnegativity to the similarity scores as ours. Also, since they only change the position embedding on the numerator while keeping the denominator unchanged, the summation of their attention scores is not equal to 1. For Stochastic Positional Encoding (Liutkus et al., 2021), they use a sampling strategy to approximate the softmax, and introduce relative positional encoding to linear transformers.

heading: 3 EXPERIMENTS
text: In this section, we experimentally validate the effectiveness of the proposed method in multiple settings. The purposes of the experiments are three-fold. First, we validate the capacity of COSFORMER in language modeling through autoregressive (Sec. 3.1) and bidirectional (Sec. 3.2) setups using WikiText-103 (Merity et al., 2017). In this way, we validate the effectiveness of the proposed linear attention module in both causal and non-causal cases. Second, we investigate the generalization ability of COSFORMER on downstream tasks by comparisons with other existing transformer variants. This is achieved by performing comparative finetuning experiments on five datasets, including GLUE (QQP, SST-2, MNLI) (Wang et al., 2018), IMDB (Maas et al., 2011) and AMAZON (Ni et al., 2019) (Sec. 3.3). We further compare COSFORMER with other transformer variants on the long-range-arena benchmark (Tay et al., 2020b) to understand its ability in modeling long-range dependencies (Sec. 3.4) and show comparative analysis into model efficiency (Sec. 3.5). Third, we conduct ablation studies to understand each component in COSFORMER (Sec. 3.6).

heading: 3.1 AUTOREGRESSIVE LANGUAGE MODELING
text: In autoregressive or left-to-right language modeling, we estimate the probability distribution of a token given its previous tokens. We use (Baevski & Auli, 2018) as our baseline model. Specifically, we adopt their large model which has 16 cascaded layers with a projected dimensions of 1024, and replace the self-attention module with our proposed linear attention module. We train our model on 8 Nvidia Tesla A100 GPUs with a sequence length of 512 for 150K updates on the WikiText-103 (Merity et al., 2017) and report perplexity on the validation and test splits in Table 2.
We observe that although the baseline model is a powerful standard transformer which requires quadratic computation complexity, COSFORMER outperforms it with a clear margin in linear computation complexity. Besides, we achieve comparable perplexity to other methods on the validation set, and significantly outperform all competing methods on the test set by a clear gap, which further demonstrates the effectiveness of COSFORMER .

heading: 3.2 BIDIRECTIONAL LANGUAGE MODEL
text: For bidirectional language modeling, we adopt RoBERTa (Liu et al., 2019) as the baseline model. Similarly, we replace the self-attention module in the RoBERTa by the proposed linear attention module, and keep other structures unchanged. We train this bidirectional task on 2 Nvidia Tesla A100 GPUs for 50K iterations with a input sequence length 512. As shown in Figure 4, COSFORMER converges faster than vanilla transformer on both training and validation sets with a comparable or smaller loss values, despite it only consumes linear space and time computation complexity. In addition, the COSFORMER variant with re-weighting mechanism has both notably better converge speed and final results over the counterpart without re-weighting, which further validates the effectiveness of our cos-based distance matrix and also demonstrates the effectiveness of recency bias on natural language data.

heading: 3.3 DOWNSTREAM FINE-TUNING TASKS
text: In this section, we fine-tune the pre-trained model on downstream tasks to demonstrate the generalization ability of COSFORMER on downstream tasks. We use the pre-trained bidirectional model and fine-tune it on three downstream text classification tasks: GLUE (QQP, SST-2, MNLi) (Wang et al., 2018), IMDB (Maas et al., 2011) and AMAZON (Ni et al., 2019). For fair comparison, we first pre-train all the competing efficient transformer variants for the same 50K iterations on WikiText103 (Merity et al., 2017) under the same setting, then we follow the same fine-tuning protocol as RoBERTa (Liu et al., 2019) to fine-tune these methods on the downstream tasks. From Table 3, we can see that COSFORMER outperforms baseline (Liu et al., 2019) on three out of five datasets, and achieves either best or secondary place on all five downstream datasets compared to competing efficient transformers. It is worth noting that despite Longformer (Beltagy et al., 2020) achieves better results on MNLI than COSFORMER , it requires a computation complexity of O(Nw), where w is window size. As shown in Figure 1, Longformer is slower and requires more memory overhead than COSFORMER . Other competing methods(Peng et al., 2020; Choromanski et al., 2020; Kitaev et al., 2019) are all based on kernel functions and have substantial performance gaps compared with our model. This validates the effectiveness of the proposed COSFORMER model compared with other efficient transformer variants.

heading: 3.4 RESULTS ON LONG-RANGE-ARENA BENCHMARK
text: To further evaluate the generalization ability of the proposed method, we train our model from scratch on Long-range-arena benchmark 2020b. Long-range-arena (Tay et al., 2020b) is a benchmark specifically designed for efficient transformers with long input sequences, thus serving as a suitable testbed to assess the quality of efficient transformer variants comparatively. To ensure fair comparison, we first implement our method on Jax (Bradbury et al., 2018), then carefully follow their preprocessing, data split, model structure and training protocol. We evaluate our method on a variety of tasks including Long sequence ListOps (Nangia & Bowman, 2018), Byte-level text classification (Maas et al., 2011), document retrieval using the ACL Anthology Network (Radev et al., 2013), image classification on sequence of pixels on CIFAR-10 (Krizhevsky & Hinton, 2009), and Pathfinder (Linsley et al., 2018). As shown in Table 4, COSFORMER overall achieves competitive results across all the tasks while achieving best performance on ListOps and Document Retrieval. For the Pathfinder task, since the distance between the two points can be very far from each other, our introduced locality bias would have negative impact to this task and show a bit lags to other SOTA methods, despite that the performance gap between our method and the vanilla transformer is small It is worth mentioning that COSFORMER achieves the best overall scores on Long-range-arena benchmark, being one of the only two models that surpass vanilla transformer architecture.

heading: 3.5 EFFICIENCY COMPARISON
text: In this section, we compare the efficiency of COSFORMER with other models, with a focus on long sequences as inputs. With the proposed linear attention module, we expect that COSFORMER scales comparably with other linear variants while significantly surpassing the vanilla transformer architecture. For a fair and comprehensive comparison, we implement our method and competing methods on Jax (Bradbury et al., 2018). We use the byte-level text classification benchmark and report runtime speed during both training and inference under different sequence lengths (1k-4k). We conduct experiments on one Nvidia A6000 GPU and also report the corresponding inferencetime memory foot prints as shown in Figure 1. As shown in Table 5 and Figure 1, most pattern based methods (Beltagy et al., 2020; Zaheer et al., 2020; Tay et al., 2020a; 2021) and vanilla transformer (Vaswani et al., 2017) are much slower and require greater memory than COSFORMER prevents them from extending to longer sequence. Further, the kernel based methods like (Narang et al., 2021; Choromanski et al., 2020; Tay et al., 2020a) have comparable speed and memory overheads, but their performances are less satisfactory compared to COSFORMER across above metrics. In summary, our model COSFORMER achieves overall better efficiency than other linear variants while maintain superior modeling and generalization ability.
3.6 ABLATION: cos-BASED RE-WEIGHTING
By introducing cos-based re-weighting, we provide a non-linear mechanism to concentrate the distribution of attention connections and stabilizes the training. In this way, we encourage the model to better take into account the locality inductive biases commonly observed on many natural language tasks. In particular, we investi-
gate the effect of the cos-based re-weighting in two aspects. First, as shown in Figure 4, by adding
cos-based re-weighting, we obtain both notably better converge speed and final results in autoregressive language modeling. Further, in Table 6, we present a comparison between COSFORMER models with and without re-weighting mechanism. We use two composite metrics which comprehensively include 10 different datasets from bidirectional downstream fine-tuning tasks and long-range-arena (Tay et al., 2020b). COSFORMER achieves overall better results over the counterpart without reweighting, improving the average scores on bidirectional finetuning and long-range-arena by a clear margin. This verifies that the proposed re-weighting effectively incorporates the locality inductive biases for natural language tasks.

heading: 4 RELATED WORK
text: This section will introduce the existing works on improving the efficiency of Transformers, they can be broadly divided into two categories, Pattern based methods and Kernel based methods.
Pattern based method Pattern based methods sparsify the attention matrix with handcrafted or learnable patterns. As an early approach, Lee et al. (2019) leverages the inducing points from the sparse Gaussian process to reduce the quadratic complexities of a transformer. Child et al. (2019) reduces the complexity by applying combination of strided pattern and local pattern to the vanilla attention matrix. Longformer (Beltagy et al., 2020) designs fixed diagonal sliding windows combined with global window, and the sliding window pattern can also be extended with dilation to enlarge the receptive field. Zaheer et al. (2020) presents a more powerful and expressive sparse attention mechanism, which combines multiple types of attention patterns and gives a thorough study of sparse attention mechanism. Instead of fixed patterns, Kitaev et al. (2019) and Daras et al. (2020) group the attention computation process into buckets by local sensitive hashing, while Roy et al. (2020) uses mini-batch spherical k-means. Nevertheless, Pattern based methods can only cope with sequences up to a certain length, and the computational complexity still grows rapidly when the input sequence becomes longer.
Kernel based method When faced with longer input sequences, it is more efficient to directly reduce the complexity of the theoretical calculation method. Kernel based methods speed up selfattention by reducing the computation complexity of self-attention from quadratic to linear. Vyas et al. (2020) approximate the full attention with a fixed number of cluster attention groups by assuming neighbouring queries in Euclidean space should have similar attention distributions. Peng et al. (2020) chooses to use the production of Gaussian kernel functions to approximate Softmax, changing the order of scale dot product calculation, thus reducing the theoretical time to linear complexity and Choromanski et al. (2020) uses Haar measurement based kernel instead. Wang et al. (2020) imports the low-rank prior for attention matrix and approximate softmax with SVD decomposition manner. Xiong et al. (2021) utilizes the Nyström method with segment-means to generate a lowrank approximation of the Softmax matrix. Katharopoulos et al. (2020) formalizes the transformer layer as a recurrent neural network. In this paper, we demonstrate that the approximation to Softmax is unneccessary for Linearization of self-attention module. We instead propose a new method to replace Softmax with a linear operation with a re-weighting mechanism, which reduces both time complexity and space complexity to O(N) while maintaining the accuracy.

heading: 5 CONCLUSION
text: We presented COSFORMER , a new efficient transformer that has linear time and space complexity. Our COSFORMER is based on two key properties of the original softmax attention: (i) every element in the attention matrix are non-negative, such that negatively-correlated information are not included for contextual information aggregation; (ii) the non-linear re-weighting scheme concentrates the distribution of the attention matrix, in order to better exploit the locality inductive biases on sequence modeling. To fulfill these properties in our COSFORMER , we utilized the RuLU function as our linear operation to ensure the non-negative property; a new cos-based re-weighting mechanism was proposed to enforce the locality bias in the original softmax attention. Since our COSFORMER is naturally decomposable, it does not suffer the accumulated approximation error that usually happens in previous linear transformers. On causal pre-training, bidirectional pre-training, and multiple downstream text understanding tasks, COSFORMER achieves comparable or even better performances than the vanilla transformer. On long sequence benchmark, COSFORMER achieved state-of-the-art performance over five different tasks. Further, COSFORMER obtains a significant overall advantage in terms of time and memory efficiency over all existing efficient transformers, facilitating the transformers to easily scale to longer input sequence.

heading: A APPENDIX
text: A.1 MATHEMATICAL DERIVATION OF cos-BASED RE-WEIGHTING
Following Equation 11, we give a detailed deviation of how to obtain output at position ith position:
Oi =
∑N j=1 f(Q ′ i,K ′
j)Vj∑N j=1 f(Q ′ i,K ′ j)
=
∑N j=1 ( Q̄cosi ( K̄cosj )T + Q̃sini ( K̃sinj )T) Vj∑N
j=1 ( Q̄cosi ( K̄cosj )T + Q̃sini ( K̃sinj )T)
=
∑N j=1 Q̄ cos i ( K̄cosj )T Vj + ∑N j=1 Q̃ sin i ( K̃sinj )T Vj∑N
j=1 Q̄ cos i ( K̄cosj )T + ∑N j=1 Q̃ sin i ( K̃sinj )T
=
∑N j=1 Q̄ cos i (( K̄cosj )T Vj ) + ∑N j=1 Q̃ sin i (( K̃sinj )T Vj ) ∑N j=1 Q̄ cos i ( K̄cosj )T + ∑N j=1 Q̃ sin i ( K̃sinj )T
(13)
where i, j = 1, ..., N,M ≥ N , and Q′ = ReLU(Q),K ′ = ReLU(K). Let Qcosi = Q ′ i cos ( πi 2M ) , Qcosi = Q ′ i cos ( πi 2M ) , Kcosj = K ′ j cos ( πj 2M ) , Ksinj = K ′ j sin ( πj 2M ) . It presents that the output of the proposed COSFORMER attention can be obtained in a linear manner.
A.2 PSEUDO CODE OF COSFORMER
Algorithm 1 describe the way to compute COSFORMER attention
Algorithm 1 COSFORMER attention Input: Q ∈ RN×d1 ,K ∈ RM×d1 , V ∈ RM×d2 ; Output: O ∈ RN×d2 ; Use Mi to represent the i-th row of matrix M ; Initialize A[i] = πi2N , O[i][j] = 0, i = 1, . . . , N, j = 1, . . . , d2; Initialize Scos[i][j] = 0, Ssin[i][j] = 0, T cos[i] = 0, T sin[i] = 0, i = 1, . . . , d1, j = 1, . . . , d2; for i in 1, . . . ,M do:
Kcosi = Ki cos ( πi 2M ) ,Ksini = Ki sin ( πi 2M ) ; Scos += (Kcosi ) T Vi;
Ssin += ( Ksini )T Vi; T cos += Kcosi ; T sin += Ksini ;
end for for i in 1, . . . , N do: Qcosi = Qi cos ( πi 2M ) , Qsini = Qi sin ( πi 2M ) ;
Oi = Qcosi S cos+Qsini S sin
Qcosi T cos+Qsini T sin ; end for
A.3 ALGORITHM TO VISUALIZE ATTENTION MATRIX
Algorithm 2 describe the way to visualize attention matrix as Figure 3
Algorithm 2 Algorithm to visualize attention matrix Input: Mk ∈ Rd×d, k = 1, . . . , n; threshold ∈ [0, 1]; Output: M ∈ Rd×d; Initialize M [i][j] = 0, i ∈ 1, . . . , d, j ∈ 1, . . . , d; for k in 1, . . . , n do:
for i in 1, . . . , d do: index = argsort(Mk[i]) (in descending order) p = 0 for j in 1, . . . , d do:
l = index[j] p += Mk[i][l] M [i][l] += 1 if p > threshold then: break end if
end for end for
end for M /= n; Use heatmap to visualize M;
A.4 INTRODUCTION OF DATASET
We train both models on autoregressive language modeling and bidirectional modeling by Wikitext103 dataset, it is split by tokens and its statistics as Table 7.Then we fine-tune the pre-trained bidirectional modeling on several text classification tasks.
QQP dataset contain thousands of sentence pair from community question-answering website Quora.Network need to determine pairs of question are semantically equivalent. SST-2 and IMDB are collections of movie reviews. The task is to determine whether a review is positive or not. AMAZON dataset contains millions of product reviews from Amazon.The requirement of this task is to infer the scoring of the product from the review text.MNLI is a crow-source collections of sentence pairs. The network must distinguish which of the three categories entailment, contradiction and neutral the given sentences belong to.
The long-range-aren benchmark contains 5 different datasets.ListOps contains some designed clever mathematical problem to clarify the parsing ability of neural models. IMDB is also used in this benchmark to examine the text classification ability of neural models. CIFAR-10 is a image collection of various of object, this task require models capture 2D spatial relations between flatten pixels.In pathfinder task, models need to determine the connection of two points in the picture, so as to examine the model’s ability to acquire 2D spatial relationships.AAN dataset is used to evaluate the ability for models to encode and store compressed representations for retrieving.
A.5 QUALITATIVE RESULTS OF LRA
We provide our qualitative results of the ListOps and Document Retrieval tasks on Long-RangeArena benchmark (Tay et al., 2020b) with a comparison to the vanilla transformer.
ListOps is a ten-way classification task which aims to prediction the results of a sequence with a hierarchical structure and operators MAX, MEAN, MEDIAN and SUM MOD that are enclosed by delimiters (brackets). The network needs to access all tokens and model the logical structure of the inputs in order to make a prediction.
Document Retrieval task is to decide whether the two input long documents are similar or not with a binary label. This task evaluates a model’s ability to encode and store compressed representations that are useful for matching and retrieval. Since the samples in LRA are too long, We substantially shorten some selected samples and display them as below:
Listops: 1 Input: ( ( ( ( ( ( ( [MED 7 ) 9 ) 3 ) 1 ...... 5 ) 6 ) 8 ) ] ) ) 2 )
8 ) 9 ) 5 ) 0 ) ] ) ) 8 ) 5 ) 1 ) 2 ) ] ) Our Output: 0, Transformer output: 9, Ground-truth: 0
2 3 Input: ( ( ( ( ( ( ( ( ( [SM 5 ) 6 ) 0 ) 7 ) 1 ) ( ( ( ( ( (...... ( (
( Input: ( ( [MIN 5 ) 8 ) 1 ) 0 ) (( [MED ( ( ( 8 ) 7 ) 2 ) 8 ) 1 ) 8 ) ] ) ) 7 ) ] )] ) Our output: 9, Transformer output: 3, Ground-truth: 9 4 5 Input: ( ( ( ( ( ( ( ( ( [MAX 7 ) 4 ) 8 ) ( ( ( ( ( ( ( ( ( ( ( [MAX 5
) 2 ) ( ( ( ( ( ( [SM 3 ) 6 ) 9 ) ( ( ( ...... ) ) 1 ) 6 ) 4 ) 2 ) ] ) ) ] ) Our output: 9, Transformer output: 5, Ground-truth: 9
Listing 1: Examples of LisOps
Byte-level document retrieval: 1 Text1: b’1 Introduction Recent advances in Statistical Machine
Translation (SMT) are widely centred around two concepts: (a) hierarchical translation processes, frequently employing Synchronous Context Free Grammars (SCFGs) and (b) transduction or synchronous rewrite processes over a linguistic ......
2 3 Text2: b’1 Introduction Automatic Grammatical Error Correction (GEC)
for non-native English language learners has attracted more and more attention with the development of natural language processing , machine learning and big-data techniques. ?The CoNLL2013 shared task focuses on the problem of GEC in five different error types including determiner, preposition, noun number......
4 5 Our output: False, Transformer output: True, Ground-truth: False
Listing 2: Examples of Document Retrieval

Review summaries:
The paper proposes a substitute of the vanilla self-attention module, which claims a linear complexity. Like Performer and many other previous works, it introduces kernel functions and change the computation order among QKV in the self-attention module. Essentially, it replaces softx with ReLU and a cosine operation. Experiments are done on several benchmarks.

This paper presents cosFormer which presents a linear operator to replace the softmax operator in calculating self-attention for transformer architectures, maintaining competitive predication accuracy while enjoying linear space and time complexity instead of quadratic costs compared to the vanilla baseline. Under this context, the authors emperically show that two factors are critical to improve the efficiency of transformers: (1) the self-attention matrix should have non-negative elements and (2) aggregating negatively-correlated information needs the non-linear re-weighting strategy. Based on the insightful analysis, the proposed cosFormer adopts ReLU and the Ptolemy’s theorem (cosine re-weighting) in designing a linear replacement of the softmax operator. The performance of cosFormer is validated with the language modeling (autogressive in both causal and non-causal cases) on WikiText-103 dataset,  the finetuning on a lot of downstream datasets such as GLUE, IMDB and AMAZON, and the comparison with state of the art methods on the long-range-arena benchmark.  

The paper proposes a variant of the transformer network. The authors base their work on their analysis of softmax attention. They argue that softmax works well because of two reasons (i) it stabilizes training due to reweighing the attention as well as associated connections within the network, and (ii) it forces non negative values in the attention matrix. Utilizing these observations, they propose two modifications (i) a linear projection kernel i.e. ReLU to compute similarity, and (ii) a cosine function for reweighing the attention values. With exhaustive experiments on 5 benchmarks, authors demonstrate that the proposed modifications lead to state of the art performance with reduced computational compelxity.   

This work introduces a simple and elegant way to incorporate recency bias for kernelized linear attention mechanism using cos-based re-weighting mechanism.  This cosine re-weighting can be effectively implemented via query and key matrix transformations for linear attention mechanisms. The authors experiment with LRA, and both language modeling with autoregressive and bidirectional setups to show the efficacy of proposed method.