Parallelizing Linear Transformers with the Delta Rule over Sequence Length

Authors: songlin  yang
bailin  wang
yu  zhang
yikang  shen
yoon  kim
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-14 21:17:01

Abstract: Transformers with linear attention (i.e., linear transformers) and state-space models have recently been suggested as a viable linear-time alternative to transformers with softmax attention. However, these models still underperform transformers especially on tasks that require in-context retrieval. While more expressive variants of linear transformers which replace the additive update in linear transformers with the delta rule (DeltaNet) have been found to be more effective at associative recall, existing algorithms for training such models do not parallelize over sequence length and are thus inefficient to train on modern hardware. This work describes a hardware-efficient algorithm for training linear transformers with the delta rule, which exploits a memory-efficient representation for computing products of Householder matrices. This algorithm allows us to scale up DeltaNet to standard language modeling settings. We train a 1.3B model for 100B tokens and find that it outperforms recent linear-time baselines such as Mamba and GLA in terms of perplexity and zero-shot performance on downstream tasks. We also experiment with two hybrid models which combine DeltaNet layers with (1) sliding-window attention layers every other layer or (2) two global attention layers, and find that these hybrids outperform strong transformer baselines.

Main paper: 
 introduction: 
 The attention mechanism [8, 112] has been shown to be an important primitive for accurate sequence modeling. Attention is moreover efficient during training as it is rich in matrix multiplications and can thus take advantage of highly parallel processing capabilities and specialized accelerators on modern GPUs. However, the complexity of attention is quadratic in sequence length, and hence it is a fundamentally expensive primitive. And while recent techniques have made it possible to scale attention to longer sequences through hardware-aware restructuring of the intermediate computations [19, 17, 57, 14] , these methods still require storing the key/value vectors of previous elements, and this "KV cache" (whose size grows linearly) can be unwieldy to manage for long sequences. Linear attention transformers [47] replace the exponential kernel in softmax attention with a dotproduct over (possibly transformed) key and query vectors. This makes it possible to formulate linear attention as a linear RNN with matrix-valued hidden states, thus obviating the need for a KV cache and enabling constant-memory inference. While initial variants of linear attention generally underperformed softmax attention on language modeling, gated variants of linear attention which incorporate a data-dependent gating factor have recently been shown to be competitive against strong transformer baselines [116, 89, 9, 77] . These gated linear transformers, along with time-varying state space models such as Mamba [30, 18] (which can be reparameterized as a gated linear transformer [116] ), have been suggested as a potential alternative to ordinary transformers. However, despiteThe parallel DeltaNet layer is made available as part of the FLASHLINEARATTENTION library [116, 115] : https://github.com/sustcsonglin/flash-linear-attention the competitive language modeling performance, these models have been shown to underperform transformers on recall-intensive tasks [6, 7] , which is important for many practical downstream tasks of interest (e.g., in retrieval-augmented generation [52] ).To enhance associative recall over long contexts, Schlag et al. [99] propose DeltaNet, a variant of a linear transformer which uses a delta rule-like update [114] to retrieve and update a value vector that is associated with the current key. DeltaNet was found to be effective on synthetic tasks and small scale language modeling/machine translation. However, the original work used a sequential algorithm that did not parallelize across sequence length, thus resulting in hardwareinefficient training, and it has not been clear how to scale DeltaNet to larger models and datasets. This work describes a hardware-efficient training algorithm for DeltaNets which parallelizes the forward/backward passes across sequence length. We reparameterize the DeltaNet as a matrix-valued RNN whose recurrence is given by a generalized Householder transformation. This reparameterization enables the use of the compact WY representation [11] for products of Householder matrices, eliminating the need to materialize the hidden states of matrix size at each time step during parallel training, which would otherwise result in high I/O costs. The memory-efficient representation makes it possible to straightforwardly extend the chunkwise parallel strategy for training linear attention models [33, 105, 116] to the DeltaNet case. We scale DeltaNets to moderate-scale language modeling benchmarks (1.3B models trained on 100B tokens), where DeltaNet is found to obtain better language modeling and zero-shot downstream task performance than strong linear recurrent models such as Mamba [30] and GLA [116] . For in-context retrieval and learning evaluation, we evaluate DeltaNet on synthetic and real benchmarks [4, 2, 82, 6] , where it is again found to perform well against linear recurrent baselines. Finally, we experiment with a hybrid approach where we combine DeltaNet layers with sliding attention layers or global attention layers, and find that these hybrid models can improve upon ordinary transformers, as well as the pure DeltaNet transformer.Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?Answer: [Yes] Justification: This paper's contributions and scope are reflected in abstract and introduction part clearly. 
linear transformer: transformers with linear attention: 
 Given a sequence of d-dimensional input vectors x 1 , . . . , x L , transformers use the softmax attention mechanism to attend over the entire past,q t , k t , v t = W Q x t , W K x t , W V x t , o t = t i=1 exp(k T i q t ) t j=1 exp(k T j q t ) v i ,where W Q , W K , W V ∈ R d×d , q t , k t , v t , o t ∈ R d . (Here we assume a single attention head for simplicity). Linear attention [47] replaces the exponential kernel exp(k T i q t ) with the dot-product φ(k i )T φ(q t ) where φ : R d → R n is a feature map. This makes it possible to rearrange computations to represent linear attention as a linear RNN with matrix-valued hidden states,o t = t i=1 φ(k i ) T φ(q t ) t j=1 φ(k j ) T φ(q t ) v i = t i=1 v i φ(k i ) T φ(q t ) t j=1 φ(k j ) T φ(q t ) = S t φ(q t ) z T t φ(q t ),where S t = t i=1 v i φ(k i ) T ∈ R d×n and z t = t i=1 φ(k i ) ∈ R n .If we allow n to go to infinity, linear attention can use feature maps associated with polynomial kernels to compute a polynomial approximation to the exponential kernel as a dot product, and can thus approximate softmax attention arbitrarily well [6] . The denominator z T t φ(q t ) ∈ R can result in numerical instabilities [84] and is removed in recent works [98, 61] . It is also common to use the identity mapping for φ [61, 105] , which results in the following simplified linear transformer:S t = S t-1 + v t k T t , o t = S t q t .Efficient training. Let Q, K, V ∈ R L×d be the stacked query, key, value vectors, e.g., Q i = q i . We can then compute the output O ∈ R L×d in parallel via O = QK T ⊙ M L V, where M L ∈ R L×L is the causal mask. This fully "parallel form" and the above "recurrent form" have different FLOPs and parallelization tradeoffs. The parallel form takes O(L2 d + Ld 2 ) and thus requires more FLOPs than the recurrent form, which takes O(Ld 2 ). However, the parallel form is often much faster in practice for moderate-length sequences as it can be done in O(1) steps. This sequence-level parallellism also enables high GPU occupancy. The recurrent form requires fewer FLOPs but cannot be parallelized across sequence length 1 and the elementwise operations involved in recurrence moreover cannot make use of specialized matmul accelerators (e.g., tensor cores).Chunkwise parallel form. The chunkwise parallel form [33, 105, 116] strikes a balance between the parallel and recurrent forms, allowing for fewer FLOPs than the parallel form and more sequencelevel parallelism than the recurrent form. Concretely, suppose the query/key/value vectors are split into L C chunks where each chunk is of length C. Let Q [t] ∈ R C×d be all the query vectors for chunk t, and let q i[t] = q tC+i be the i-th query vector within the t'th chunk; the key/value chunks are defined similarly. Note that t ∈ [0, L/C), i ∈ [1, C]. The state matrices are also re-indexed such that S i[t] = S tC+i , and we additionally define S 0 [t] = S C [t-1] , i.e., the initial state of a chunk is the last state of the previous chunk. We can then obtain the following identity for the hidden state and output vector for the r-th element within the t-th chunk,S r [t] = S 0 [t] + r i=1 v i [t] k i T [t] , o r [t] = S 0 [t] q r [t] + r i=1 v i [t] k i T [t] q r [t].By further rewriting the intra-chunk computation based on the parallel form, we obtain following,EQUATIONEQUATIONwhere we letS [t] = S 0 [t]to reduce notational clutter. With this "chunkwise parallel form", information is propagated chunk-to-chunk through S [t] , and the intra-chunk states S i[t] for i ∈ [1, C] need not be materialized, thus saving memory.The complexity of the chunkwise parallel form is O(LCd + Ld 2 ), and the number of steps (without chunk-level parallel scan) is O( L C ). Hence, C = L recovers the fully parallel form and C = 1 recovers the recurrent form. The chunkwise parallel form allows us to interpolate between the two forms, in essence trading off the number of sequential computations against sequence-level parallelism. In practice C is set to a small constant (usually 64 or 128), allowing for subquadratic training. This chunkwise form enables practical speed-ups against parallel-form-only softmax attention even on moderate-length sequences, as demonstrated by FLASHLINEARATTENTION [116, 115] The above linear transformer employs a simple linear recurrence: S t = S t-1 + v t k T t . This can be seen as additively updating the memory S t-1 with new key-value associations at each time step. However, a purely additive update rule makes it difficult to deallocate past key-value associations, eventually leading to key "collisions" when L > d, as pointed out by Schlag et al. [98] . A model should ideally learn to remove less important key-value associations to make room for new ones, and this removal should depend on the interaction between the new key and the memory content.DeltaNet uses the delta update rule [114] to operationalize this mechanism. Specifically, it first retrieves the old value using the current key, v old t = S t-1 k t . It then obtains a new value v new t by interpolating between the old value and the current value v t , which replaces v old t in the memory:v new t = β t v t + (1 -β t ) v old t , S t = S t-1 -v old t k T t remove +v new t k T t writeHere β t = σ(W β x t ) ∈ (0, 1) is a soft "writing strength": when β t = 1, the old value is completely removed and v new t = v t ; when β t = 0, the memory remains unmodified and we have S t = S t-1 . The output computation is the same as vanilla linear attention, i.e., o t = S t q t . The complexity of this recurrent form is the same as that of vanilla linear attention, i.e., O(Ld 2 ). This DeltaNet is a special case of fast weight programmers [100] , and Schlag et al. [98] and Irie et al. [36] show that this type of linear transformer outperforms ordinary linear transformers on small-scale language modeling and synthetic in-context retrieval tasks.Since the old value vector depends on the previous hidden state S t-1 , it is not possible to straightforwardly apply the above chunkwise parallel strategy for training DeltaNet transformers. While the official implementation from Schlag et al. [98] avoids materializing the S t 's (thus minimizing I/O cost) by using the linear-time-constant-memory algorithm from Katharopoulos et al. [47, §3.3.1] , it still uses the pure recurrent form and thus does not parallelize across the sequence dimension, which makes it difficult to scale DeltaNet to modern language modeling settings.Question: Does the paper discuss the limitations of the work performed by the authors?Answer: [Yes] Justification: We discuss the limitations of this work in §5.3.Guidelines:• The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper. • The authors are encouraged to create a separate "Limitations" section in their paper.• The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be. • The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated. • The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon. • The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size. • If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness. • While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations. 
parallelizing deltanet across the sequence dimension: 
 In the same spirit as the chunkwise form of linear attention, we derive a chunkwise form for DeltaNet that enables hardware-efficient training through parallelizing across the sequence dimension.We first observe that S t admits a purely additive representation of the formS t = t i=1 u i k T i for u i , k i ∈ R d , since we can simply set u i = v new i -v old i = β i (v i -v old i ).Recall from §2.1 that simple linear attention has the form S t = t i=1 v i k T i . Thus, DeltaNet simply replaces the value vector v i in linear attention with the "pseudo" value vector u i . Once the u i 's have been constructed, the rest of computation can proceed as in ordinary linear attention, i.e., O = QK T ⊙ M U where U ∈ R L×d is the row-wise concatenation of the u i vectors.However, computing u t naïvely requires explicitly materializing S t-1 to compute v old t , which would require O(d 2 ) memory. We now show that we can obtain the u t 's without explicitly materializing S t-1 in O(d) memory. Our simple proof (by induction) relies on an application of the WY representation for products of Householder matrices [11] . The base case is clear since we haveS 1 = β 1 v 1 k T 1 , so u 1 = β 1 v 1 .For the inductive step, we first observe that the DeltaNet update is given by,S t = S t-1 -v old t k T t + v new t k T t = S t-1 -β t (S t-1 k t ) k T t + β t v t k T t = S t-1 (I -β t k t k T t ) + β t v t k T t ,which can be seen as applying a generalized Householder transformation (i.e., matmul with an identity plus rank-one matrix) to the previous state. The inductive step is then given by,EQUATIONNote that u t does not require materializing any of the hidden states and requires O(d) memory to compute, thus completing the proof. While we have avoided materializing S t 's, computing u t 's for all L (that is, U) takes O(L 2 d) and moreover cannot be fully parallelized, unlike in linear attention where we can calculate all the value vectors V in parallel in O(1) steps. We now show that the above trick still enables an efficient chunkwise parallel form for DeltaNet.To derive the chunkwise parallel form, we first unroll the recurrence,EQUATIONWe then define the following variables:P j i = j t=i (I -β t k t k T t ) ∈ R d×d , H j i = j t=i β t (v t k T t )P j t+1 ∈ R d×d, where we let P j i = I whenever i > j. Intuitively, P j i is the "decay factor" to be applied to S i for obtaining S j , and H j i represents the contributions to S j starting from token i. (Hence S t = H t 1 ). The chunkwise recurrence can then be written as,EQUATIONwhere we define the chunkwise variables S ∈ R d×d matrices using a similar approach described in §3.1, so that these matrices can be stored in O(d) memory,EQUATIONThe derivations for the above can be found in the appendix. Subsequently, based on Eq. 5, we can obtain the chunk-level recurrence for hidden states and outputs as,S r [t] = S 0 [t] -S 0 [t] r i=1 w i [t] k i T [t] + r i=1 u i [t] k i T [t] = S 0 [t] + r i=1 u i [t] -S 0 [t] w i [t] k i T [t] , o r [t] = S r [t] q r [t] = S 0 [t] q r [t] + r i=1 u i [t] -S 0 [t] w i [t] k i T [t] q i [t] .LettingS [t] = S 0 [t], the above can be simplified to matrix notations similarly to Eq.1-2,EQUATIONEQUATIONwhere[t] = 1:C [t] ∈ R C×d for ∈ {Q, K, V, O, U, W} defines the chunkwise matrices that are formed from stacking the q t , k t , v t , o t , u t , w t vectors.Practical considerations. In the above, Eq. 7 is fully recurrent and thus cannot use tensor cores written as is. To solve this, we further leverage the UT transform [43, 22] :EQUATIONEQUATIONto rewrite most operations in matmuls. The inverse of lower triangular matrices could be solved efficiently using forward substitution. Once computed, the hidden state updates (Eq. 8) and the output computations (Eq. 9) are largely the same as in vanilla linear attention. We adapt FLASHLINEARAT-TENTION [116] to implement Eq. 8 and 9 with hidden states recomputed during the backward pass for saving GPU memory. The PyTorch pseudocode for the forward pass is shown in Listing 1. Speed comparison. We implement both the pure recurrent form2 and the chunkwise parallel form in Triton [109] and show the speed-ups for various sequence lengths (L) and head dimensions (d head ) in the right figure, where the model dimension d is 2048 and we vary batch size and sequence length so that they multily to 16384. 3 Our chunkwise algorithm achieves greater speed-ups as sequence length L and head dimension d head increase, where the use of sequence-level parallelism (for high GPU occupancy) and tensor core (for fast matmuls) become more important [116, §3] .Fully Parallel Form for DeltaNet. For completeness, we also discuss the fully parallel form of DeltaNet. While we use the concept of a "pseudo" value, it is possible to avoid modifying values. From Eq. 4, it is straightforward to compute the attention matrix A: A ij = k T j P i j+1 q i if j ≤ i and 0 otherwise. Notably, A has the matrix form A = QK T ⊙ M T, obtained by combining Eq. 3 and 11. However, computing T requires a matrix inverse (Eq. 10), which scales cubically with sequence length without further algorithmic changes. Due to the above we avoid using the fully parallel form for training DeltaNet; however the "attention" matrix derived from this form could be of interest to the interpretability research community studying RNNs, as explored in Ali et al. [3] and Zimerman et al. [123] .We describe how the DeltaNet layer primitive is used to build up a transformer-like model using standard modules. We largely follow the LLaMA-architecture [Transformer++, 111] and simply replace the self-attention layer with the DeltaNet layer. We also apply normalization before output projection for stable training [84, 66] . As the additional parameters for computing scalar β t terms are negligible, parameter allocation is roughly the same as in Transformer++, i.e., 4d 2 for the DeltaNet layer and 8d 2 for the SwiGLU FFN layer [101] .Feature map and normalization. Our key/query vectors are given by kt = SiLU(WK xt) SiLU(WK xt) 2 , q t = SiLU(WQxt)SiLU(WQxt) 2 . Schlag et al. [98] originally follow Katharopoulos et al. [47] and apply a "ELU + 1" [16] to nonlineary transform the key/query vectors. We instead use the SiLU activation [23] , which was found to perform better [86, 18] . For stability, it is crucial to ensure that the norm of each eigenvalue of the transition matrices does not exceed one. The eigenvalues of I -β t k t k T t are 1 with multiplicity d -1 and 1 -β t k t 2 with multiplicity 1. Schlag et al. [98] used the L 1 norm to normalize query/key vectors, ensuring that 0 ≤ 1-β t k t 2 ≤ 1. We instead apply L 2 normalization, which we found to perform better and offers a more intuitive interpretation: whenβ t = 1, I -k t k T tbecomes a projection matrix, erasing information in one subspace while preserving the other d -1 subspaces. This is beneficial for retaining information while enabling more targeted forgetting.Following recent work on combining subquadratic token-mixing layers with existing neural network primitives [6, 20, 53] , we also experiment with hybridizing DeltaNet models.Convolutional layers. Recent linear recurrent models typically incorporate a lightweight depthwise-separable convolution layer after the query/key/value projections [30, 9, 18] . This "short convolution" layer [81] generalizes the shift SSM [25] , and is efficient in both number of parameters and computational cost. We also add a short convolution layer after the query/key/value projections.Local sliding window and global attention. Linear attention largely uses a content-based addressing mechanism [28] and lacks positional information [120] . Arora et al. [6] also argue that linear attention lacks the ability to perform precise local token shifts and comparisons, thus facing difficulties on retrieval-intensive tasks. Motivated by this, we experiment with two different hybrid architectures that incorporate softmax attention. We first explore sliding window attention (SWA) which has been shown to significantly improve linear attention [84, 6, 55, 72] ; we follow Griffin [20] and Samba [93] to interleave DeltaNet layers and SWA layers. We also experiment with global attention, which has been found to be helpful [50, 34] even if only few of the recurrent layers are replaced with global attention [53] . We follow Fu et al. [25] to replace only two layers with global attention: the second layer and the ( N 2 + 1)-th layer, where N is total number of layers.Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof? Answer: [NA] Justification: This paper does not include theoretical results that require a full proof. Guidelines:• The answer NA means that the paper does not include theoretical results.• All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced. • All assumptions should be clearly stated or referenced in the statement of any theorems. • The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition. • Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material. • Theorems and Lemmas that the proof relies upon should be properly referenced. 
empirical study: 
 We compare the DeltaNet against strong baselines in both synthetic and real-world language modeling settings. Our main baselines include: LLaMA-architecture Transformer++ [111] ; RetNet [105] , a linear attention Transformer with non-data-dependent exponential decay and large head dimension; GLA [116] , a linear attention Transformer with data-dependent decay; and Mamba [30] , a selective state-space model with data-dependent decay. MQAR evaluates language models' ability to (in-context) recall information within a context when faced with multiple recall queries. We use Arora et al. [4] 's training setting and for DeltaNet we use 2 heads. We do not use convolutions for these experiments. Figure 2 shows that DeltaNet performs perfectly (even without convolution) in the hardest setting and outperforms Mamba (which uses convolutions) in the low-dimension setting. Next, we consider the MAD benchmark [82] , a suite of synthetic token Finally, we consider RegBench [2] , a synthetic data set designed to assess the in-context language learning capability of different model architectures. Each input sequence in this benchmark consists of 10 to 20 strings drawn from a distinct language defined by a probabilistic finite automaton (PFA), so that a model needs to infer the underlying language from the context on the fly. During testing, a model is evaluated on predicting the next token of testing sequences generated from held-out PFAs. Here again we find that DeltaNet performs strongly compared to baselines, as shown in Figure 3 .Experimental setup. Following prior work [30, 116] , we evaluate on Wikitext perplexity and zero-shot common sense reasoning tasks, including LAMBADA [LMB.; 74], PiQA [12] , Hel-laSwag [Hella. ; 118] , WinoGrande [Wino.; 96], ARC-easy (ARC-e) and ARC-challenge (Arc-c) [15] . Following Arora et al. [6] , we also evaluate the models real-world recall-intensive tasks, including FDA [5] , SWDE [58] , and SQUAD [91] . Both SWDE and FDA focus on extracting structured information: SWDE from raw HTML to identify semi-structured relationships, and FDA from PDFs to retrieve key-value pairs. SQUAD evaluates language models on reading comprehension by providing a text passage and a related question. See §D for hyperparameter settings. Results. Our main language modeling results are shown in Table 2 . Since Mamba uses convolutions by default while GLA does not, we retrain the GLA with convolution, and also train DeltaNet without convolution. For the 1.3B setting we only train the DeltaNet with convolution due to limited compute resources. In general we find that DeltaNet outperforms the strong Mamba/GLA baselines in terms of both perplexity and downstream task performance. For recall-intensive tasks (i.e., SWDE, SQuAD, FDA), we find that under the same state size at the 340M scale, DeltaNet outperforms GLA, confirming the effectiveness of the delta rule. However, at the 1.3B scale, DeltaNet underperforms GLA due to its poorer state size scability (see §5.3), since state size plays an important role in recallintensive tasks. Finally, we confirm the benefits of hybrid architectures [20, 53] : both the sliding window and global attention hybrids work well, outperforming the strong Transformer++ baselines.We also scale DeltaNet to the 3B parameter scale trained with 1T tokens using the same settings as Shen et al. [102] . The results are shown in Table 3 , where 3B DeltaNet slightly underperforms a Transformer architecture trained with the same setting (PowerLM-3B), but outperforms other RNN baselines in the 2B-3B range (though these are trained for a different number of tokens so are not exactly comparable). Ablations. In Table 2 (bottom) we ablate the choice of feature map and normalization. We find that simply replacing the L 1 -norm with the L 2 -norm greatly increases performance. For the feature map, we experiment with {ReLU, 1 + ELU, SiLU} and find that SiLU performs the best, consistent with prior work [86] .Training throughput. 5 Discussion and Related WorkQuestion: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)? Answer: [Yes] Justification: The paper provides sufficient details on hyperparameters and training procedures in §D to reproduce the results supporting its main conclusions. Guidelines:• The answer NA means that the paper does not include experiments.• If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not. • If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable. • Depending on the contribution, reproducibility can be accomplished in various ways.For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed. • While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. , with an open-source dataset or instructions for how to construct the dataset). (d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility.In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results. Justification: We provide information of GPU type and number of GPUs used for running our experiments.Guidelines:• The answer NA means that the paper does not include experiments.• The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage. • The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute. • The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper). 
deltanet vs. state space models / linear rnns: 
 To discuss DeltaNet against existing linear RNNs (including state-space models) we first introduce a general class of associative RNNs with matrix-valued hidden states. Given a matrix-valued hidden state S t ∈ R d×n and current input x t ∈ R d , these models have the following form:S t = S t-1 • M t + v t k T t , (recurrence) o t = S t q t , (memory read-out)where • is an associative operator (e.g., Hadamard product, matrix multiplication, etc.). The matrix M t and vectors v t , k t , q t are (potentially non-linear) functions of the current input x t .As is the case in vector-valued linear RNNs [62, 103] , the use of an associative operator enables the use of parallel scan [13] to calculate S 1 , . . . , S L in O(log L) steps and O(L) work (ignoring the terms associated with the associative operation) if the inputs x 1 , . . . , x L are given (though see our discussion in footnote 1). Hence, as long as the associative operator is not too expensive, training can be efficient. However, parallel scan by itself is not sufficient for training language models at practical scale due to some associative operator's being too expensive. Recent models such as such Model Recurrence Memory read-out Linear Attention [47, 46] St = St-1 + vtk T t ot = Stqt + Kernel St = St-1 + vtφ(kt) T ot = Stφ(qt) + Normalization St = St-1 + vtφ(kt) T , zt = zt-1 + φ(kt) ot = Stφ(qt)/(z T t φ(qt)) DeltaNet [98] St = St-1(I -βtktk T t ) + βtvtk T t ot = Stqt Gated RFA [79] St = gtSt-1 + (1 -gt)vtk T t , zt = gtzt-1 + (1 -gt)kt ot = Stqt/(z T t qt) S4 [31, 103] St = St-1 ⊙ exp(-(α1 T ) ⊙ exp(A)) + B ⊙ (vt1 T ) ot = (St ⊙ C)1 + d ⊙ vt ABC [80] S k t = S k t-1 + ktφ T t , S v t = S v t-1 + vtφ T t ot = S v t softmax S k t qt DFW [61] St = St-1 ⊙ (βtα T t ) + vtk T t ot = Stqt RetNet [105] St = γSt-1 + vtk T t ot = Stqt Mamba [30] St = St-1 ⊙ exp(-(αt1 T ) ⊙ exp(A)) + (αt ⊙ vt)k T t ot = Stqt + d ⊙ vt GLA [116] St = St-1 ⊙ (1α T t ) + vtk T t = St-1Diag(αt) + vtk T t ot = Stqt RWKV-6 [77] St = St-1Diag(αt) + vtk T t ot = (St-1 + (d ⊙ vt)k T t )qt HGRN-2 [89] St = St-1Diag(αt) + vt(1 -αt) T ot = Stqt mLSTM [9] St = ftSt-1 + itvtk T t , zt = ftzt-1 + itkt ot = Stqt/ max{1, |z T t qt|} Mamba-2 [18] St = γtSt-1 + vtk T t ot = Stqt GSA [122] S k t = S k t-1 Diag(αt) + ktφ T t , S v t = S v t-1 Diag(αt) + vtφ T t ot = S v t softmax S k t qtTable 4 : Overview of recent linear recurrent models that have been proposed and applied to autoregressive language modeling (ordered in rough chronological order). These works make use of a matrix-valued hidden state St ∈ R d×n (or two matrix-valued hidden states S k t , S v t , e.g., [80, 122] ) updated through an associative recurrence followed by an outer-product-based addition. Here ⊙ is the Hadamard product. Some models make use of an additional linear RNN with hidden state vector zt, which used to normalized the query vector qt. Variables with the subscript t (e.g., vt, αt, ft, γt) are (potentially non-linear) functions of the current input xt. Non-time-varying parameters (e.g., A, d, γ) are denoted without subscripts; these parameters are either learned or set to fixed values. Matrices are denoted with bold upper case letters, vectors with bold lower case, and scalars with italic letters. Many models make use of a kernel φ (e.g., [98, 79] ) but we subsume them into the key/value vectors to reduce notational clutter.as Mamba [30] and gated linear attention Transformers [105, 116, 89, 77, 9] thus make use of cheap element-wise recurrence updates, in particular the Hadamard product, i.e., • = ⊙. See Table 4 for how recent models can be cast into this form.Standard matrix multiplications (i.e., S t-1 • M t = S t-1 M t ) on the other hand can model richer interactions that go beyond elementwise recurrence. Without any structural assumptions on M t however, these operations would take O(dn 2 ) for each update (as opposed to O(dn) for elementwise products), which would be prohibitively expensive. Hence, DeltaNet's use of M t = I -β t k t k T t can be seen as exploiting structured matrices to efficiently model interactions beyond elementwise recurrences. Our chunkwise algorithm could generalize to a broader class of matrices in the Diagonal-Plus-Low-Rank (DPLR) form M t = Da t b T t , which has been explored in S4 [31] , although their DPLR transition matrices are data-independent. We adopt DeltaNet's parameterization in this work (i.e., D = I, a t = β t k t , b t = k t ) as we are primarily interested in improving recall (through DeltaNet's key-value update rule) while maintaining parameter efficiency. We leave the exploration of more generalized parameterizations for future work.While the above class of models makes it possible to unify recent models, we do not claim that it is the "right" level at which view (autoregressive) sequence transformations of the form{x t } L t=1 → {o t } L t=1, where o t cannot depend on any x j if j > t. For example, this framing makes it difficult to (neatly) capture other subquadratic models that have been shown to be effective [117, 48, 95, 81 ]. An alternative unifying framework might be to view the above sequence transformations as a discretization of a continuous state space model [31, 103, 30] , or as a matrix multiplication with a masked structured matrix [73, 85, 45, 18] . What does seem important, however, is that a framework should ideally expose efficient algorithms for training, and the algorithm should be hardware-efficient, which, in the case of modern GPUs, means that it should be rich in matrix multiplications. From this perspective, the state-space duality (SSD) framework recently proposed by Dao and Gu [18] , which provides a connection between SSM-based sequence transformations and structured matrix multiplications with a semiseparable matrix, seems a promising candidate. However, this framework may not capture an important class of models, e.g., models where the associative recurrence involves matrix multiplication with an unstructured matrix, or models that make use of more exotic associative operators (e.g., in Peng et al. [78] ).Finally, we observe that there have been many recent linear-time models that have been proposed which purportedly match or outperform classic transformers. As can be seen in Table 4 , the "sequence mixing" component of these works are closely related to one another. However, the way in which the token-mixing primitive is used to build up a transformer-like model varies widely. For example, while most recent works make use of depthwise-separable convolution layers (not shown in Table 4 ) [30, 76, 90, 9, 18] , earlier works generally do not [47, 99, 79] . There are also differences in the parameterizations of the feedforward layers used for the "channel mixing" component. Such variations should be taken into account before declaring a particular model layer superior to another.Our work has several limitations. First, in terms of computation, although we propose a new hardware-efficient algorithm, the training speed still lags behind that of GLA. This is due to the overhead caused by modeling state-to-state dependencies as described above, which requires "marginalizing" over the head dimension inside the kernel, similar to the case of softmax attention. However, for GLA since there are no intra-state dependencies (everything is elementwise), and thus it is easy to use tiling to support arbitrary size of head dimension, as implemented in Yang and Zhang [115] . This limitation would potentially limit DeltaNet's memory size, consequently lowering the recallintensive task performance as we observed in §4.2. However, it may be feasible to adopt block diagonal generalized Householder transition matrices with block sizes fitting GPU SRAM (e.g., 128) while maintaining a overall large head dimension (and thus a large recurrent state size).We also found that the length generalization of DeltaNet was limited, 4 while GLA and RetNet (and Mamba to an extent) have been found to be able to extrapolate beyond the training length [116] . We speculate that this is because DeltaNet lacks explicit decay factors. This could be improved through incorporating a gating term in the recurrence, which we leave for future work. 
related work: 
 We briefly discuss related work here and give an extended discussion in Appendix C. Linear transformers can be seen as a type of iterated Hopfield networks [69] , and this connection can provide perspectives on the limitations and improvements of linear attention transformers. For example, vanilla linear transformers use a Hebbian-like update rule, which has been shown to have limited memory capacity [65] . Later works in Hopfield networks use higher-order polynomials [21] and exponential kernels [92, 49] to enhance the memory capacity, which is also related to attention with polynomial kernels explored in PolysketchFormer [44] and Based Linear Attention [6, 1] . On the other hand, the delta rule has been shown to have better memory capacity [27, 83, 54, 97] . In this sense, given the fixed size recurrent state, using the delta rule is able to achieve a better frontier of the recall-memory tradeoff curve [6] , and has recently been applied to enhance real-world retrieval tasks [71, 94] . Moreover, it outperforms the additive rule used in vanilla linear transformers across multiple domains [98, 36, 39, 35, 41] . Despite these advantages, Irie et al. [41] revealed theoretical limitations of the delta update rule in terms of expressiveness. Recurrent enhancements of DeltaNet, such as Recurrent DeltaNet [37] and the Modern Self-Referential Weight Matrix [40] , were proposed and found to be superior in Irie et al. [41] . However, these models extend beyond linear RNNs and cannot be parallelized across sequence length. This suggests a fundamental trade-off between parallelism and expressiveness [67] . How to further enhance DeltaNet without sacrificing parallelism remains an open question, and the hybrid cross-chunk nonlinear and intra-chunk linear strategy used in TTT [107] might provide a suitable middle ground. Finally, we remark that delta rule is closely related to meta or online learning via gradient descent [70, 38] , which has been revisited in recent works like Longhorn [56] and TTT [107] . 
conclusion: 
 We describe an algorithm that parallelizes DeltaNet training across the sequence length dimension, achieving significant speed-ups against existing implementations on modern hardware. This makes it possible to scale up DeltaNet to moderate-scale language modeling settings, where we find that it performs well compared to recent linear-recurrent baselines. 
code of ethics: 
 Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines?Answer: [Yes] Justification: This work follows the NeurIPS Code of Ethics.Guidelines:• The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.• If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics. • The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction). 
broader impacts: 
 Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?Answer: [NA] Justification: We foresee no potential societal impact of this work.Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?Answer: [NA] Justification: We foresee no such risks posed by this work.Guidelines:• The answer NA means that the paper poses no such risks.• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. • Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. • We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.12. Licenses for existing assets Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?Answer: [Yes] Justification: All of the datasets we use are publicly available at huggingface site, and we have properly cited all the training and evaluation datasets we used.Guidelines:• The answer NA means that the paper does not use existing assets.• The authors should cite the original paper that produced the code package or dataset.• The authors should state which version of the asset is used and, if possible, include a URL. • The name of the license (e.g., CC-BY 4.0) should be included for each asset.• For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.• We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution. • For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review. 
 
 Appendix: To reduce notational clutter, we only discuss the first chunk here.We first show P n = I -n t=1 w t k T t by induction, P n = n t=1 (I -β t k t k T t ) = P n-1 (I -β n k n k T n ) = (I - n-1 t=1 w t k T t )(I -β n k n k T n ) = I - n-1 t=1 w t k T t -β n k n k T n + ( n-1 t=1 w t k T t )β n k n k T n = I - n-1 t=1 w t k T t -β n k n -β n n-1 t=1 w t (k T t k n ) wn k T n = I - n t=1 w t k T t Similarly, we show S n = n t=1 u t k T n by induction, S n = S n-1 (I -β n k n k T n ) + β n v n k T n = n-1 t=1 u t k T t (I -β n k n k T n ) + β n v n k T n = n-1 t=1 u t k T t - n-1 t=1 u t k T t β n k n k T n + β n v n k T n = n-1 t=1 u t k T t + β n v n -β n n-1 t=1 u t k T t k n un k T n = n t=1 u t k T n B Pseudo code 1 def chunk_delta_rule_forward(Q, K, V, beta, C): 2 ''' 3 Q/K/V: query, key, value of shape [L, d]Chunkwise linear attention. Hua et al. [33] first proposed chunkwise form for linear attention; however, they used a hybrid linear and nonlinear attention model similar to Munkhdalai et al. [71] . It is possible to adapt their algorithm to compute the exact output of the pure linear attention, as shown in Sun et al. [105] and Yang et al. [116] . The chunkwise linear attention algorithm has also been independently discovered in several works [105, 44, 18] . Yang et al. [116] and Qin et al. [88] discuss I/O-aware hardware optimization for chunkwise linear attention and Sun et al. Hybrid models. There has been much recent work on developing hybrid models by combining linear recurrent layers (state-space models, linear recurrent Transformers, linear RNNs) with local chunk attention [59, 121, 24, 60, 71] or sliding window attention [121, 6, 20, 93] or global attention [50, 51, 34, 25, 53, 75, 106] . Poli et al. [82] systematically study the scaling law of hybrid models. We similarly show that combining DeltaNet with classic attention is an effective strategy.Householder matrices. Householder matrices, known for preserving norms, are a type of orthogonal matrix extensively used in machine learning [64, 68, 119, 110, 87, 10] . These matrices allow for efficient computation of inverses and their Jacobian determinant of one, making them particularly suitable for applications in normalizing flows [64, 10] . Notably, Mathiasen et al. [64] developed a chunkwise fast algorithm for computing the cumulative product of Householder matrices for normalizing flows, leveraging the WY representation. Our approach, while sharing the same high-level concept, tackles a different problem and is arguably more general.There has also been significant interest in using orthogonal matrices to parameterize the transition matrices of RNNs [68, 42, 113, 32] for mitigating vanishing gradients. Mhammedi et al. [68] use the WY representation to reduce the memory footprint when training nonlinear RNNs with Householder transition matrices.We used 8 H100 GPUs for 340M and 1.3B language modeling experiments. Each model uses AdamW for optimization, with a peak learning rate of 3 × 10 -4 . The 340M models are trained using 15 billion tokens and a batch size of 0.5M tokens, while the 1.3B models are trained with 100 billion tokens and a batch size of 2M tokens. We use a cosine learning rate schedule, starting with a warm-up phase of 0.5 billion tokens for the 340M models and 1 billion tokens for the 1.3B models. Both configurations have initial and final learning rates set at 3 × 10 -5 . We apply a weight decay of 0.01 and use gradient clipping at a maximum of 1.0. The head dimension of DeltaNet is set to 128, and the kernel size for convolution layers is set at 4.• The answer NA means that the abstract and introduction do not include the claims made in the paper. • The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers. • The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings. • It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.It is possible in theory to use parallel scan[13] to parallelize the recurrent form, which would enable the computations to be performed in O(log L) steps and O(Ld) FLOPs. However, this approach requires materializing the 2D hidden state for each time step, which would incur significant memory I/O cost unless the state size is small enough such that materialization can happen in faster memory (i.e., as in Mamba[30]).Note that our recurrent kernel is already 2× faster than the original CUDA kernel from Schlag et al.[99].So far we have been assuming a single head (dhead = d) for easier exposition. In practice we use multiple heads where the head dimension dhead is smaller than the model dimension d. We thus have St ∈ R d×d head .However we found the DeltaNet + local sliding-window attention hybrid to generalize well, which could provide an appealing middle ground. 


Decision: It is well-known that standard softmax dense attention has quadratic complexity with respect to sequence length.  In recent years, there has been a great deal of interest in linear transformers, which have O(N) complexity, a fixed-size memory, and a theoretically unlimited context.  In practice, of course, it is not possible to fit an unlimited context into a fixed-size memory, so the "delta rule" introduces a mechanism that allows linear transformers to forget.

Unfortunately, the delta rule is not necessarily easy to implement efficiently in practice.  This paper develops an efficient parallel implementation of the delta rule, using the WY representation for computing products of Householder matrices.  The authors validate the effectiveness of the implementation with a variety of experiments, and also introduced new and compelling results on the MAD benchmark during the discussion period.

The reviewers were unanimous in recommending acceptance, and I concur.

Despite the overall high scores, my personal opinion is that the space of "alternatives to softmax attention" is at this point very crowded.  IMO, the primary reason for considering alternatives is to enable long-context.  However, the "forget" mechanism is not necessarily well-suited to long-context, and as the authors explain in the discussion, the models they are using (1-3B params) are too small for good long-context experiments.  As a result, although I believe this paper is a solid contribution, I don't recommend it for a spotlight or oral.

Reviews: review: paper_summary: paper_summary: This paper proposes a hardware-efficient algorithm for training linear transformers with a delta update (DeltaNet; SMS21). This architecture has an attention formulation that prevents the direct application of chunk-wise parallel algorithms for computing its output. To address this issue, the authors introduce a re-parameterization of DeltaNet as a matrix-valued RNN whose recurrence is given by a generalized Householder transformation. This enables the use of WY representation which is memory efficient and eliminates the need to materialize the hidden state matrices. Experiments on synthetic benchmarks and language modeling tasks shows competitive performance compared to strong baselines (Mamba, GLA) and faster speed than the original Deltanet implementation.
strength_weakness: strength_weakness: - W1. In terms of scale, the model explores two different architectures of increasing size up to 1.3B parameters. Even though this size is considerable, it is still relatively small compared to the LLMs that are widely used such as Llama, Mistral (7B+ size). There is always the question of whether the quality is maintained with further model increase.
- W2. The improved results compared to Mamba and GLA make use of additional architectural components: convolution and local/global attention, without them the results are comparable to the other models.
questions: questions: - Q1: What is the effect of chunk size in the chunk-wise parallel algorithm for DeltaNet? Varying the chunk size $C$ and showing its effect in efficiency would be interesting to explore. 
- Q2: The chunk-level hidden states $S_{[t]}$'s are discarded to save memory. From Eq. 7, it seems that their computation depends on the previous hidden states $S_{[t-1]}$'s. Are these kept in memory for the re-computation in the backward pass?  
- Q3: GLA with convolution performs worse than w/o convolution with the larger model size. Do you expect this to be the case for DeltaNet as well? It would be good to add this result if possible. 

Minor:
- In Table 2, is the L1/L2 norm referring to the normalization of queries and keys? Please specify. 
- In Eq.1, why is this equation showing the state $S_{[t+1]}$ instead of $S_{[t]}$? The latter is used in Eq. 2. Same for Eq. 7.  
- l172: stable -> stabilize
- l213-214: we -> we follow
- l321: vallina -> vanilla
limitations: limitations: Yes, they have.
paper_summary: paper_summary: This paper introduces a novel algorithm for the efficient training of DeltaNet Linear Transformers. DeltaNet enhances contextual associative recall using a delta rule-like update but was previously limited by inefficient parallelization in its training algorithm. The work described in this paper presents a hardware-efficient algorithm that leverages the memory-efficient WY representation for computing products of Householder matrices, enabling the scaling of DeltaNet similar to other linear Transformer models. The authors trained a 1.3B parameter model on 100B tokens and found that it outperforms strong linear-time baselines such as Mamba and GLA in terms of perplexity and zero-shot performance on downstream tasks.
strength_weakness: strength_weakness: The algorithms presented in this paper are satisfactory in terms of efficiency and performance.
questions: questions: I have no questions for this paper.
limitations: limitations: Yes
paper_summary: paper_summary: This paper proposes the Delta Rule method to construct the state updates for Linear Attention. Furthermore, the paper introduces a chunk-wise training approach, allowing the computational cost of training to grow subquadratically with the text length. Experimentally, the paper validates the effectiveness of the model architecture using three synthetic benchmarks: MQAR, MAD, and RegBench. Additionally, the paper uses Common Sense Reasoning and Retrieval tasks in LLM pre-training to verify the model's performance in real-world tasks. The model has been validated at scales ranging from 340M to 1.3B parameters. Furthermore, this paper explores the possibility of combining the Delta Rule with Sliding Window Attention and Global Attention, demonstrating the positive impact of the hybrid architecture on model performance.
strength_weakness: strength_weakness: 1. Have you conducted experiments on long context? For example, measuring extrapolation and scenarios akin to "looking for a needle in a haystack"? As a linear model, I would like you to further discuss its capability to generalize to long context.
2. The algorithmic speed of Delta Net increases linearly, but it seems to be slower than GLA. Can you analyze the factors contributing to this?
3. Could you further explain the insights of the Delta Net updates? I understand there are algorithmic differences compared to GLA operators, but what unique benefits do they bring? Is there any theoretical analysis?
questions: questions: I would like to discuss the following questions with you:

Do you think linear models can fundamentally bridge the gap with transformers in memory-based tasks?

Is there an inherent conflict between the ability to handle long context and the performance of memory-based tasks?
limitations: limitations: N/A

Comments: title: Response to authors
comment: Thanks for your response. Your responses solve my concern to some extent. I maintain my score.
Thanks for your feedback!

## The potential issue is that DeltaNet without convolution is in several tasks worse than GLA without convolution. Any insight on why that is? 

Local information plays a critical role in NLP tasks. As highlighted in [3], incorporating more local features can significantly enhance the performance of linear attention. Many recent studies also demonstrate that additional local attention mechanisms greatly improve linear attention.

Short convolutions are one method to enhance local information, while the gating mechanism in GLA imposes a strong inductive bias towards local context. DeltaNet’s update rule, on its own, doesn’t prioritize local information, so without short convolutions, it may underperform in NLP tasks. However, when short convolutions are applied, DeltaNet’s ability to leverage local context is improved. Since GLA already incorporates gating mechanisms to enhance local information, short convolutions may not provide additional benefits.

Additionally, it’s important to note that both the delta rule and the vanilla linear attention update rules can be seen as "context-based addressing" mechanisms. [1] emphasizes the importance of "location-based addressing," and [2] also highlights that a drawback of linear attention is its "lack of precise local token shifts and comparisons." The gating mechanism in GLA addresses this by emphasizing nearby tokens, while short convolutions can be considered another form of location-based addressing.


- [1] https://arxiv.org/abs/1410.5401 Neural Turing Machines 

- [2] https://arxiv.org/abs/2402.18668 Simple linear attention language models balance the recall-throughput tradeoff

- [3] https://arxiv.org/abs/2312.11135 Linear Attention via Orthogonal Memory


## For completeness, I'd suggest adding some discussion about it to emphasize that it's essential

Thank you for your suggestion! We will include this discussion in the next iteration of the paper draft to emphasize its importance.
Thank you for answering my questions and providing additional results!

- The experiments with 3B model provide evidence that performance is comparable to that of a Transformer as model size increases to 3B. Given the compute constraints, my concern has been addressed adequately. 

- Regarding the convolutional component, I am not challenging the fairness of the comparison. The potential issue is that DeltaNet without convolution is in several tasks worse than GLA without convolution. Any insight on why that is? For completeness, I'd suggest adding some discussion about it to emphasize that it's essential to the performance of DeltaNet and reporting the results of DeltaNet w/o convolution for the 1.3B model, which are currently missing. 

- I found the results about the effect of chunk size insightful; it'd be good to include these results in the final version. 

My questions and concerns have been answered adequately except the second bullet point above. Hence, I decided to keep my original scores.
Thanks for the response, the authors addressed my concerns, and I have raised my score.