Looking Beyond the Top-1: Transformers Determine Top Tokens in Order

## Abstract

Abstract Understanding the inner workings of Transformers is crucial for achieving more accurate and efficient predictions. In this work, we analyze the computation performed by Transformers in the layers after the top-1 prediction has become fixed, which has been previously referred to as the “saturation event”. We expand the concept of saturation events for top- k 𝑘 k italic_k tokens, demonstrating that similar saturation events occur across language, vision, and speech models. We find that these saturation events happen in order of the corresponding tokens’ ranking, i.e., the model first decides on the top ranking token, then the second highest ranking token, and so on. This phenomenon seems intrinsic to the Transformer architecture, occurring across different architectural variants (decoder-only, encoder-only, and to a lesser extent full-Transformer), and even in untrained Transformers. We propose an underlying mechanism of task transition for this sequential saturation, where task k 𝑘 k italic_k corresponds to predicting the k 𝑘 k italic_k -th most probable token, and the saturation events are in fact discrete transitions between the tasks. In support of this we show that it is possible to predict the current task from hidden layer embedding. Furthermore, using an intervention method we demonstrate that we can cause the model to switch from one task to the next. Finally, leveraging our findings, we introduce a novel token-level early-exit strategy, which surpasses existing methods in balancing performance and efficiency.

## 1 Introduction

In recent years, Transformer-based models (Vaswani et al., ) have achieved state-of-the-art performance in various tasks across multiple modalities, including text generation, image classification, and automatic speech recognition (Zhang et al., ; OpenAI et al., ). This has lead to a growing interest in model interpretability, which tries to explain the internal processes that give rise to these remarkable capabilities. In the language domain, investigation into the way the model’s predictions are constructed has led to the discovery of *saturation events*, where the model’s top-1 prediction is determined in an early layer and remains fixed in subsequent layers (Geva et al., ).

In this work, we address the following question – *what computation is the Transformer model performing after the saturation event?* Taking inspiration from Frydenlund et al. (), we treat the model’s output as a ranking over the labels instead of a probability distribution. Using the logit lens (Nostalgebraist, ), we project the hidden states of intermediate
layers onto the vocabulary space to extract ranking over tokens and analyze the changes over the layers. For the first time, we show that in a decoder-only text Transformer (GPT2-XL; Radford et al., ) saturation events also take place for the top ranking tokens beyond the top-1 (2nd, 3rd, 4th, etc.).
Surprisingly, we find that they happen *in order* of their ranking, i.e. the second-ranking token is determined only after the first-ranking token, and so forth (see in Figure 1).
We then generalize the results across different modalities and Transformer variants, including pretrained Transformers for both vision (encoder-only ViT-L/16; Dosovitskiy et al., ) and speech (encoder-decoder Whisper-large; Radford et al., ). Next, we demonstrate that sequential saturation seems intrinsic to the Transformer architecture, occurring even in an *untrained* randomly initialized model (GPT2-XL).

We propose that this phenomenon is due to a discrete *task-transition* mechanism, where each task $i$ corresponds to the model determining the $i$-th token in the final ranking, and the transition between one task and the next happens at the corresponding saturation layer. Furthermore, we find that the task information is encoded in the layer embeddings and that at each saturation layer, a discrete “switch” is flipped, signaling that the relevant token has been determined, causing the model to move on to the next task while keeping this token fixed in subsequent layers. To support this, we show that it is possible to predict the task index from the layer embeddings using a simple logistic regression classifier, and that we can cause the model to transition from the first to the second task by “injecting” embeddings from either the top-1 saturation layer or of one of the subsequent layers.

Figure: Figure 1: An illustration of the proposed task-transition mechanism wherein the layers of the Transformer perform a changing number of tasks in order, so that task $i$ is determining the $i$-th token in the final ranking, and the transition between task $i$ and task $i+1$ occurs at the corresponding $i$-th saturation layer. The transition is akin to a switch being flipped “on” and staying “on” for the remaining layers representing the $i$-th token being fixed from this point onward.
Refer to caption: extracted/5937591/fig_1_w_lightup_switch_new.png

Finally, we show that our findings lend themselves to practical applications in improving both model efficiency and accuracy. Based on this new understanding of the Transformer, we define a new early-exit decision strategy for text generation. Early exiting is a technique where the model can make a prediction and terminate the computation before reaching the final layer, thus improving efficiency (Schwartz et al., ). In our method, the early-exit layer is the first one predicted to belong to task 2, presuming that after the transition from task 1 to task 2, the top-1 token represents the model’s final prediction. We show that this strategy outperforms existing token-level measures, such as softmax-response and hidden-state saturation (Schuster et al., ). In addition, we show that we can use task information to achieve more accurate language models, by demonstrating that in cases where the top-1 prediction is incorrect, the second highest ranking token represents a much more accurate prediction when it reaches saturation than when it does not.

Our main contributions are:

- •
We find that Transformers tend to decide their top ranking tokens in order, so that the top ranking token is fixed first, then the second-ranking token at a later layer and so on. We show that this occurs across various modalities and variants of the Transformer architecture, and even in untrained randomly initialized models.
- •
We show that sequential saturation can be explained with a discrete *task-transition* mechanism, encoded in the representation of hidden layers where each task corresponds to determining the next ranking token. We empirically show that it is possible to predict the task index only from internal activations, and that we can cause the model to switch from one task to the next via an intervention procedure.
- •
We show that these observations can be leveraged to achieve better downstream performance in early exiting and language modeling, in terms of both accuracy and efficiency.

The code for our experiments is available
at [https://github.com/daria-lioubashevski/beyond_top1](https://github.com/daria-lioubashevski/beyond_top1).

## 2 Experiments

Figure: Figure 2: Schematic of our framework and visualization of the ordered saturation of the top-k tokens on GPT2-XL. The hidden states from each layer are projected onto the vocabulary space using the unembedding matrix $E$, then sorted in descending order and treated as rankings. The saturation effect is marked separately for each token in the top-4 of the final ranking, emphasizing the fact that the 2nd token saturates after the 1st token, the 3d token saturates after the 2nd token and so on. The dashed line represents the previously established saturation event of the top-1 token.
Refer to caption: extracted/5937591/figure_2_new.png

In this section, we formulate two experiments to understand what computation the Transformer is performing in the layers after the top-1 saturation event. To achieve this, we first extend the formal definition of top-1 saturation to account for arbitrary i-th ranking token saturation (Section 2.1). Then, in Section 2.2, we leverage this definition to develop a metric capturing the extent to which the top tokens are saturated in order. In Section 2.3, we describe a probing method measuring whether it is possible to determine the rank of the token currently being considered by the model solely from the intermediate representation of the layer, without any additional context.

### 2.1 Defining Saturation Layers

###### Definition 2.1 (1st Saturation Layer; Geva et al., 2022 ) .

The saturation event occurs at layer $l$ (from here on referred to as the “1st saturation layer”) for index $i$ in the input if the top-1 prediction of the model remains constant in all subsequent layers after $l$. Formally, given a model with $N$ layers, a saturation event occurs at layer $l\leq N-1$ if for all layers $l^{\prime}$ s.t. $l<l^{\prime}\leq N$ the top-1 token in the ranking induced by that layer remains unchanged.
For example, the saturation event marked with a dashed line in Figure 2 occurs on layer 44, since in subsequent layers the top predicted token (“toy”) remains constant.

###### Definition 2.2 ( $k$ -th Saturation Layer) .

Here, we are interested in examining model behavior beyond the determination of the top ranking token and so naturally extend the definition of top-1 Saturation (Definition 2.1) to capture the layer at which the $k$-th top token is determined and remains fixed.
Formally, the saturation event for the $k$-th top token at index $i$ in the input occurs at layer $l^{k}\leq N-1$ (from here on referred to as the “ k-th saturation layer”) if for all following layers $l^{\prime}$ s.t. $l^{k}<l^{\prime}\leq N$ the token in position $k$ in the ranking induced by that layer remains unchanged. We note that the saturation event defined in (Geva et al., ) happens at $l^{1}$.
For example, in Figure 2, $l^{1}=44$ as that is where the top token (“toy”) is determined; $l^{2}=45$, since the second-most probable token (“ball”) is determined at layer 45; and similarly $l^{3}=46$, since the third-most probable token (“ribbon”) is determined at layer 46, etc.(^1^11In all of our experiments, we only consider tokens in the input where the 1st saturation layer satisfies that $l^{1}\leq 0.85\cdot N$, to ensure that there are enough layers after it for meaningful analysis.)

###### Definition 2.1 (1st Saturation Layer; Geva et al., 2022 ) .

###### Definition 2.2 ( k 𝑘 k italic_k -th Saturation Layer) .

### 2.2 Examining the Order of Saturation Layers

We investigate whether the saturation layers of the top-k tokens $l^{1},l^{2},\ldots l^{k}$ are arranged in order, i.e., whether the saturation of the first token happens before the saturation of the second token, the saturation of the second token happens before the saturation of the third token and so on. To this end, for each token in the input we first calculate these saturation layers for $k=1,\ldots,5$ according to Definition 2.2 and then for each $k$ compute the rank of the saturation layer of the $k$-th top token. We use $k=5$ to ensure consistency across models, as it is the highest value of $k$ where the $k$-th token reaches saturation in at least $5\%$ of input tokens for all the models analyzed.
Following our example from Figure 2, we have $l^{1}=44,l^{2}=45,l^{3}=46,l^{4}=47$,(^2^22$l^{5}$ is ill-defined in this case as the 5-th token doesn’t reach saturation before the last layer.) and their ranking is $[1,2,3,4]$, since $l^{1}<l^{2}<l^{3}<l^{4}$.
If the tokens reach saturation in order of ranking, as they do in this case, we would expect the average rank of the saturation layers to increase monotonically with $k$.

### 2.3 Probing for Task Transition

We argue that the mechanism underlying the saturation of the top-k tokens in order is one of task transition, such that determining the identity of each token in the final ranking is a separate task, and the model performs them sequentially: first determining the identity of 1st token, then the identity of the 2nd token, and so on, and that the transition from one task to the next occurs at the corresponding saturation layer. Additionally, we claim that the specific task number can be inferred from the model embedding at each layer, and that this information is independent of the context or the specific token predicted by the model.

To test this hypothesis, we perform a type of probing in which we train a simple one-versus-all multi-class logistic regression classifier to predict the number of the task the model is “working on” from the hidden state embeddings of the model.  We collect the data for training by extracting the model’s hidden states during inference and categorize them into 5 classes according to the saturation layers of the top-5 tokens for each instance. This means that for a given input, embeddings from layers up to (and including) the 1st saturation layer are classified as belonging to task 1, embeddings from layers from the next layer until the 2nd saturation layer are classified as belonging to task 2, and so forth, for tasks 1 through 5. For example, in the case of the token ”a” as depicted in Figure 2, the embeddings from layers 1 through 44 would be classified as belonging to task 1; the embedding of layer 45 would be classified as belonging to task 2; the embedding of layer 46 would be classified as belonging to task 3; the embedding of layer 47 would be classified as belonging to task 4; and as the model reaches the last layer directly afterward there would be no embedding classified as belonging to task 5.

We balance the training data so that embeddings from all layers are represented equally in each class. To show that the task number is encoded in the model’s embeddings and is not an artifact of the classifier’s weights, we construct a control setting where, for each class, we generate random vectors with the same dimension, drawn from a normal distribution with the mean and variance of the layer embeddings in that class.

## 3 Results

To show the robustness of our findings, we test pretrained Transformer models on corresponding datasets from three modalities: text, vision and speech.

Figure: (a) Pretrained GPT2-XL
Refer to caption: extracted/5937591/pre_trained_gpt2_barplot.png

### 3.1 Text Transformer

We first conduct our experiments on a pretrained GPT2-XL model, an auto-regressive decoder-only LLM, using 60K tokens taken from 100 randomly sampled texts from CNN/DM dataset (Hermann et al., ).

Tokens reach saturation in order of ranking. Figure 3(a) shows the average rank of the k-th saturation layer for each $k$. This value increases monotonically with $k$, and the difference between each two consecutive token ranks is statistically significant with $p<0.001$ based on a pairwise independent samples t-test. This supports our claim that saturation events happen sequentially according to token ranking in this LLM.
To statistically validate this phenomenon we use a stricter version of Kendall’s $\tau$ coefficient, where we also consider ties as disagreements (see Appendix A.1 for details and mathematical formulation). This is done to discount cases where two or more tokens reach saturation at the same layer. The coefficient takes values in the range $[-1,1]$ where values close to 1 indicate strong agreement, and values close to -1 indicate strong disagreement between the rankings. To check whether the sequence of saturation layers of the top-$k$ tokens $(l^{1},..,l^{k})$ is strictly increasing, we use that sequence as one ranking, and the sequence $(1,2,..,k)$ as the other. $k$ is set independently for each token in the input to be the largest token index such that this token’s reaches saturation by our definition i.e. $l^{k}<N$. The average $\tau$ coefficient indicates moderate agreement between the rankings, which is larger than all values over 1K permutations, where the saturation layers sequence were randomly shuffled for each instance, resulting in $p<0.001$.

Task number can be predicted from model embeddings. We split the data into train and test using 5-fold cross validation, and report the mean and standard error of the accuracy. Table 1 shows that the logistic regression classifier trained on embeddings extracted from pretrained GPT2-XL model achieves very high accuracy, while the classifier trained on the random embeddings in the control setting performs approximately at chance level (see Appendix A.3 for accuracy and ROC-AUC scores per class).
From this we conclude that the representations of the hidden layers across examples encode task specific information and that the saturation layers as we defined them are the points of transition between those tasks.

### 3.2 Vision Transformer

Encoder-only image-classification ViTs take as input a sequence of linear projections of equal-sized image patches with added position embedding and a special “class token” denoted [CLS]. Following the work of (Vilas et al., ) we use a version of the logit lens adapted to ViT to project the hidden state representations of each layer in the encoder onto the class embedding space using the output embedding matrix. Importantly this is done only for the [CLS] token for each image under the assumption that it best represents the model’s prediction, since during ViT’s pretraining the only token projected onto the class-embedding space is the [CLS] token from the last layer.

**Table 1: Accuracy of task number logistic regression classifier showing that in all modalities the layer embeddings contain information about the task number.**
| Model | Layer Embeddings | Random Embeddings | Chance Level |
| --- | --- | --- | --- |
| GPT2-XL (pretrained) | $\textbf{91.4}\pm 0.3$ | $20.6\pm 0.5$ | 20.0 |
| GPT2-XL (random initialization) | $\textbf{86.1}\pm 0.7$ | $32.7\pm 0.1$ | 33.3 |
| ViT-L/16 (pretrained) | $\textbf{63.8}\pm 0.1$ | $21.0\pm 0.5$ | 20.0 |
| Whisper-large (pretrained) | $\textbf{52.7}\pm 0.1$ | $24.5\pm 0.4$ | 25.0 |

For our experiments we use the ViT-L/16 variant pretrained on ImageNet-21k and fine-tuned on ImageNet 2012, which has 1K classes and 24 layers, and run inference on 5K randomly sampled images from the CIFAR-10 (Krizhevsky et al., ) dataset. Figure 3(b) demonstrates the high correspondence between saturation layer and token rank, and the stricter Kendall’s $\tau$ coefficient indicates a moderate agreement between the saturation layers order and the sequence $(1,2,..,k)$ which is statistically significant with $p<0.001$ (see Appendix A.1), supporting our claim that in this domain as well as in text the saturation layers are highly ordered. Furthermore, Table 1 shows that the task index can be predicted from the hidden layer activations with high accuracy well above chance and control setting.

### 3.3 Speech Transformer

Whisper is an encoder-decoder Transformer model trained on many different speech processing tasks, including ASR. Although recently there have been attempts to increase efficiency in ASR, such as Malard et al. (), the concept of early exit has yet to be explored in this setting, and to the best of our knowledge there has not been work done concerning saturation events in speech models. We adapt the logit lens and apply it only to the decoder stack of Whisper-large, which has 32 layers, under the assumption that representations in the encoder stack are inherently different and projecting them onto the token vocabulary space would not be meaningful. For our dataset we randomly sample 5K audios from LibriSpeech (Panayotov et al., ).

In addition to reproducing the classical top-1 saturation event established in language and vision models in previous work, we also show in Figure 3(c) evidence for the tendency of the top-k tokens to reach saturation in order in this model as well, albeit only up to the third token. Moreover, a permutation test performed on the stricter Kendall’s $\tau$ coefficient demonstrates that the agreement between the token ranking and the order of saturation layers is statistically significant with $p<0.001$ (see Appendix A.1). We suspect that the order deteriorates in later tokens due to the fact that each layer in the decoder is conditioned on the last layer of the encoder which may interfere with the task transition mechanism by “blurring the lines” between the tasks. Even so, Table 1 shows that the task index can be predicted from Whisper’s decoder layers’ embeddings for tasks 1 through 4 with accuracy much higher than chance or that achieved in the control setting.

## 4 Analysis

We have shown that top-k tokens tend to reach saturation in order of their ranking, as well as the plausibility of the underlying task transition mechanism over multiple modalities and variants of Transformers: decoder only, encoder only and full Transformer; in section 4.1 we argue that this phenomenon is inherent to the architecture itself and in section 4.2 we delve deeper into the way the model transitions between tasks, demonstrating that we can cause the model to switch to the next task using an intervention procedure.

### 4.1 Untrained Transformers Also Determine in Order

We repeat our experiments on an untrained  GPT2-XL with randomly initialized weights on the same amount of randomly sampled tokens from CNN/DM dataset as with the pretrained model.  Surprisingly, Figure 3(d) shows that the top-k tokens tend to reach saturation in order up to the 4th token, and although the stricter Kendall’s $\tau$ coefficient is lower than in the pretrained GPT2-XL model (see Appendix A.1), it is still statistically significant.

Figure: Figure 4: *Left*: Forward pass of two input tokens (“wanted” and “the”) in the same context for which the model’s final top-1 prediction is the same (“artist”), but the 1st saturation layers are different (25 and 40 respectively). *Right*: By injecting the output from the top-1 saturation layer of “the” as input to the subsequent layer of “artist”, we trigger a saturation at the injected layer (26) in the post-intervention run, without altering the top-1 prediction. Saturation layers are marked in bold. The use of activations from adjacent layers is not depicted for the sake of clarity.
Refer to caption: extracted/5937591/figure_4_new.png

In addition, Table 1 shows that the task transition classifier’s accuracy is more than $2.5x$ times higher than chance or that of the control setting. The ability of the classifier to extract the task index from the hidden layers’ representations in this setting is especially remarkable, demonstrating that despite the randomness of the weights as well of the identities of the predicted tokens, there is still highly ordered information encoded in the model originating only from the constraints of the architecture.

### 4.2 Intervening in Layer Activations Causes Task Switch

Using the probing analysis, we demonstrated that the tasks, as we defined them, are distinct enough to be separated by a simple classifier, that saturation layers mark the boundaries between them, and that the task index is encoded in the hidden layer embeddings. We argue that in addition, each saturation layer encodes the signal to transition to the next task, and all subsequent layers contain the information that the previous task has been completed and that the relevant token is fixed. This can be thought of as switch being flipped “on” for each token that reaches saturation, and remaining ”on” from the saturation layer onwards.

Figure: Figure 5: *Flipping the Top-1 Switch.* The percentage of examples where the top-1 saturation occurred at the injected layer after the intervention, shown as a function of the layer from which the injected activations were taken, relative to the original saturation layer (e.g., $-2$ means activations were taken from two layers before the original saturation layer).
Refer to caption: extracted/5937591/interv_result_all_models.png

To causally validate this claim, taking inspiration from Stolfo et al. (), we perform an intervention (visualized in Figure 4) in which we “inject” the output from the 1st saturation layer of sample $s_{1}$ as input into the subsequent layer in the run on sample $s_{2}$ and check how this affects the 1st saturation layer of $s_{2}$. If these activations contain the signal to switch to the next task, we expect this intervention to cause the model to switch to task 2 at the injected layer in the post-intervention run, i.e. in the new post-intervention run the 1st saturation layer should be the one on which the intervention is performed which is $l^{1}(s_{1})+1$. To minimize the effect of confounding factors, we choose pairs of samples $s_{1}$ and $s_{2}$ that share context and where the original top-1 prediction of the model is the same, but there is a big difference in their 1st saturation layers s.t. $l^{1}(s_{1})<l^{2}(s_{2})$. In the example depicted in Figure 4 $s_{1}=``wanted"$ and $s_{2}=``the"$, and for both the model’s top-1 next-word prediction is “artist”, but $l^{1}(s_{1})=25$ while $l^{1}(s_{2})=40$. Injecting the output of layer $l^{1}(s_{1})$ into the subsequent layer (26) in the run for $s_{2}$ should cause the model to switch to task 2, resulting in layer 26 being the new 1st saturation layer post intervention.

Moreover, we would expect the same thing to happen when injecting activations from a layer $l$ after the 1st saturation layer, i.e. $l>l^{1}(s_{1})$, since they should contain the information that the top-1 token is fixed. On the other hand, activations from a layer $l^{\prime}$ before the 1st saturation layer, i.e. $l^{\prime}<l^{1}(s_{1})$ should not result in saturation at the injected layer as the switch is still “off” in our analogy, indicating to the model that it still working on task 1. To test this, we repeat the same steps with activations from 5 layers before and after the 1st saturation layer $[l^{1}(s_{1})-5,l^{1}(s_{1})+5]$ each time injecting them as input into the subsequent layer.

Figure 5(a) shows the results of this procedure performed using pretrained GPT2-XL on 200 token pairs taken from 5 randomly sampled texts from the CNN/DM dataset, Figure 5(b) shows similar results reproduced using ViT-L/16 on 200 pairs of images from CIFAR-10 dataset, and Figure 5(c) shows the results of the intervention on Whisper-large on 200 token pairs from 100 randomly sampled audios from LibriSpeech (^3^33See Appendix A.4 for a formal description of the procedure as well as details on how we adapted it for vision and speech modalities). There is a stark difference in the effect the injected activations have on the 1st saturation layer post-intervention when the activations are taken from the 1st saturation layer in the original run or one of the following layers, compared to the layers before it. When the injected activations are taken from an earlier layer, the new top-1 saturation almost never occurs at the injected layer, whereas when the injected activations are taken from the saturation layer or a later layer the top-1 saturation occurs at the injected layer in a high percentage of cases. This drastic change resembles a step function, and is in line with our description of a switch being flipped ”on” at the 1st saturation layer and remaining turned on in all subsequent layers, indicating to the model to switch to the next task and keep the top-1 constant.

## 5 Practical Applications

In this section, we show that our findings can be leveraged for computation efficiency and better performance in LLMs.

### 5.1 New Early-Exit Strategy

We propose a new token-level dynamic inference method based on the task-transition classifier described in Section 2.3, where the early exit layer for each token is defined as the earliest layer which is predicted to belong to task 2 by the classifier. The idea being that once the model has transitioned into the second task, it has finished with the first task of determining the top-1 token.

To demonstrate the viability and advantages of this method, we compare it to two other local confidence measures introduced by Schuster et al. (): softmax response (the difference between the top two values of the logits after softmax) and hidden-state saturation (cosine similarity between two consecutive layer embeddings), both recently found to be competitive with other early exiting methods (Zhou et al., ). Since dynamic decoding is not the focus of this paper, we calculate the metrics for each measure while propagating states from the layers after the “early exit” as in regular inference.(^4^44This is an informative comparison between the measures, as the effect of a state copying mechanism for skipped layers on model’s performance is negligible Schuster et al. ().)

Table 2 shows our results on a pre-trained GPT2-XL model and 100 randomly sampled texts from CNN/DM dataset. We evaluate the model on next-word prediction, and compute the speedup ratio for each method as the number of layers it uses for each token divided by the total number of layers in the model, and average across all tokens. For the two other local confidence measures we calculate these metrics at various thresholds (see details in Appendix A.5), while in our metric the class is selected based on the highest predicted score among all classes. Our method outperforms the other two when considering the trade-off between next-word prediction accuracy and speedup ratio, and requires no training besides that of a simple logistic regression classifier on a relatively small amount of data.

**Table 2: Highest accuracy and corresponding speedup-ratio achieved by each early-exit strategy.**
|  | Softmax Response | State Saturation | Ours |
| --- | --- | --- | --- |
| Accuracy | $35.9\pm 0.6$ | $37.5\pm 0.7$ | $\textbf{40.0}\pm 0.7$ |
| Speedup Ratio | $1.126\pm 0.004$ | $1.003\pm 0.001$ | $\textbf{1.185}\pm 0.009$ |

### 5.2 Improved Language Modeling

Popular decoding methods in language generation such as top-k (Fan et al., ) or top-p (Holtzman et al., ) sample the next token according to the shifted distribution induced by probabilities of the top ranking tokens. Based on our task-transition mechanism and the assumption that the tasks represent relevant computation, we argue that top ranking tokens that are determined in the last layer represent less meaningful predictions, since the model only had enough layers for the first task in these instances.

To test this hypothesis we compare the accuracy of the second ranked token in the next word prediction task between two conditions: (1) the second token’s saturation layer is at least 7 layers before the output, to increase the chances that this is a “true” saturation as the model had enough layers to change its (recurring error) prediction and it is not due to noise; (2) the second token does not saturate, and is determined only in the last layer. In both cases we only look at examples where the top-1 token is not the correct prediction. The number of layers in the first setting is a hyper-parameter, and future work should investigate its affects on the second ranked token accuracy.

Using 100 randomly sampled texts from CNN/DM dataset and pretrained GPT2-XL predictions, we find that in the first condition the accuracy is 31.99%, and in the second condition it is only 17.14%. A Two Proportion Z-Test indicates a statistically significant difference between the groups ($p<0.001$). This supports our claim that top-k tokens that reach true saturation are more plausible than those that are determined only in the last layer, which has potential implications for generation decoding strategies which consider tokens beyond the top-1.

## 6 Related Work

There are multiple ways of thinking about the role of intermediate layers in Deep Neural Networks (DNNs) in general, and Transformers in particular. The iterative inference hypothesis interprets each layer as an iteration from an iterative and convergent process (Simoulin & Crabbé, ), suggesting that each layer incrementally refines the hidden representation by gradually shaping the next token prediction (Geva et al., ; Belrose et al., ; Rushing & Nanda, ). We argue that our findings challenge this view, given the discrete nature of the tasks in the proposed task-transition mechanism and the sharp transitions between them.

Pruning is another approach, focused on mitigating the redundancy inherent to large machine learning models by removing unnecessary parameters. Recent work has applied structured pruning methods to Transformer based LLMs, dropping whole modules, from self-attention layers (Artzy & Schwartz, ; He et al., ) to full Transformer blocks (Sun et al., ; Men et al., ). These studies often focus on the middle layers of the model, and claim to reduce memory and computation costs without degrading performance on downstream tasks. It’s important to note that these works evaluate the accuracy before and after pruning based only on the top-1 prediction of the model, even though stochastic generation methods such as top-p (Holtzman et al., ) and top-k (Fan et al., ) are preferable to deterministic decoding in certain settings such as open-ended tasks as they produce more coherent and varied text (Shi et al., ). In light of this and of our results regarding the sequential saturation of top ranking tokens, we suggest that future work takes this into account, since what may seem as redundancy is actually necessary computation that is not reflected in the measured metric.

The logit lens has also been used to study intermediate layers in a wide variety of interpretability papers (Yang et al., ; Wendler et al., ; Halawi et al., ). Despite this, Belrose et al. () claim that it can produce implausible results due to the difference in representations between layers. To address this issue they introduce the “tuned lens”, in which an affine transformation is learned for each layer in the model with a distillation loss, so that its image under the unembedding matrix matches the final layer logits as closely as possible. Although this method may be better at approximating final top-1 prediction from intermediate layers, our work highlights why this might actually be a disadvantage when attempting to gain insights into the computational process of the Transformer, as it could obscure the changing dynamics of the lower ranked tokens.

## 7 Conclusion and Future Work

This paper systematically investigates the unexplored question of what computation is performed by the Transformer layers following a top-1 saturation event. We find that the top-k tokens (for $k>1$) go through similar saturation events in the order of their ranking. We argue that this phenomenon is inherent to the Transformer architecture, replicating our results on an untrained model and demonstrating its robustness over multiple modalities: text, vision, and (to a lesser extent) speech. We then provide evidence in support of a task transition as underlying mechanism for this ordered saturation, showing that we can predict task index from the hidden layers’ embeddings, as well as cause the model to switch from the first task to the second via an intervention procedure. Our findings also hold promise in improving inference efficiency and next word prediction accuracy as suggested by the preliminary results in the Practical Applications section.

Limitations and Future Work
Although our analysis sheds light on the high-level task transition mechanism behind the ordered saturation of top-k tokens, there is still a need for more work to determine which components in the Transformer architecture give rise to it, via ablation studies for example, as well as more concrete explanation for how the model keeps the “chosen” tokens constant after their saturation events across remaining layers. In addition, we did not consider whether the model encountered the data used in our experiments during training as a relevant factor. Finally, as we only explored Transformer architectures, it is necessary to check whether other types of DNNs also determine their top-k tokens in order. Recurrent Neural Networks (RNNs) might be of particular interest due to their mathematical equivalence to decoder only Transformers (Oren et al., ), and based on previous work successfully applying the logit lens to them to extract meaningful predictions from intermediate layers (Paulo et al., ).

## 8 Acknowledgements

We would like to thank Nir Rosenfeld, Omri Abend and Mariano Schain for the invaluable insights, as well as Noam Dahan and Timna Wharton Kleinman for their helpful feedback.

## Appendix A Appendix

### A.1 Stricter Kendall’s tau

We define a version of Kendall’s tau coefficient measuring the ordinal association between two tanking, where one-sided ties are considered discordant unlike the regular metric, where ties are typically either ignored or handled as neutral, meaning they neither count as concordant nor discordant.

Given two rankings $x=(x_{1},x_{2},.,x_{n})$ and  $y=(y_{1},y_{2},.,y_{n})$, let $\text{pair}(i,j)$ be a pair of indices where $1\leq i<j\leq n$.

We define the pair as concordant if the rankings in both sequences agree, meaning:

$$ $(x_{i}>x_{j}\,\text{and}\,y_{i}>y_{j})\quad\text{or}\quad(x_{i}<x_{j}\,\text{ and}\,y_{i}<y_{j})\quad\text{or}\quad(x_{i}=x_{j}\,\text{and}\,y_{i}=y_{j})$ $$

The pair is discordant if:

$$ $(x_{i}>x_{j}\,\text{and}\,y_{i}<y_{j})\quad\text{or}\quad(x_{i}>x_{j}\,\text{ and}\,y_{i}>y_{j})\quad\text{or}\quad(x_{i}=x_{j}\,\text{and}\,y_{i}\neq y_{j} )\quad\text{or}\quad(x_{i}\neq x_{j}\,\text{and}\,y_{i}=y_{j})$ $$

The coefficient $\tau_{\text{strict}}$, is computed as:

$$ $\tau_{\text{strict}}=\frac{C-D}{C+D},$ $$

where $C$ is the number of concordant pairs, and $D$ is the number of discordant pairs (including ties), ranging in values between $[-1,1]$.

Table 3 summarizes the results of this metric across the different models discussed in the paper, along with the p-values of the permutation test performed for the mean $\tau_{strict}$ for each.

**Table 3: Stricter Kendall’s tau coefficients and p-values for each model**
| Model | $\tau_{strict}$ (avg $\pm$ ste) | $p_{value}$ | $\tau_{strict}>0$ |
| --- | --- | --- | --- |
| GPT2-XL (pre-trained) | $0.187\pm 0.004$ | $<0.001$ | $67.39\%$ |
| GPT2-XL (random initialization) | $0.082\pm 0.009$ | $<0.001$ | $49.48\%$ |
| ViT-L/16 (pre-trained) | $0.149\pm 0.007$ | $<0.001$ | $58.94\%$ |
| Whisper-large (pre-trained) | $0.210\pm 0.009$ | $<0.001$ | $63.78\%$ |

### A.2 Training Data for Task Transition Classifier

Table 4 shows from which layers we took embeddings to train the task-transition classifier for each model.

**Table 4: Task transition probing per-class accuracy scores**
| Model | Layers | Dataset size |
| --- | --- | --- |
| GPT2-XL (pre-trained) | $23-40$ | $6K$ |
| GPT2-XL (random initialization) | $31-41$ | $2K$ |
| ViT-L/16 (pre-trained) | $16-21$ | $2K$ |
| Whisper-large (pre-trained) | $29-32$ | $4K$ |

### A.3 Per Class Metrics for Task Transition Classifier

**Table 5: Task transition probing per-class accuracy scores**
| Model | Task 1 | Task 2 | Task 3 | Task 4 | Task 5 |
| --- | --- | --- | --- | --- | --- |
| GPT2-XL (pre-trained) | $0.862$ | $0.92$ | $0.926$ | $0.921$ | $0.941$ |
| GPT2-XL (random initialization) | $0.782$ | $0.83$ | $0.972$ | $-$ | $-$ |
| ViT-L/16 (pre-trained) | $0.646$ | $0.618$ | $0.603$ | $0.644$ | $0.678$ |
| Whisper-large (pre-trained) | $0.520$ | $0.528$ | $0.484$ | $0.576$ | $-$ |

**Table 6: Task transition probing per-class ROC-AUC scores**
| Model | Task 1 | Task 2 | Task 3 | Task 4 | Task 5 |
| --- | --- | --- | --- | --- | --- |
| GPT2-XL (pre-trained) | $0.966$ | $0.987$ | $0.974$ | $0.974$ | $0.985$ |
| GPT2-XL (random initialization) | $0.929$ | $0.951$ | $0.995$ | $-$ | $-$ |
| ViT-L/16 (pre-trained) | $0.855$ | $0.821$ | $0.809$ | $0.829$ | $0.866$ |
| Whisper-large (pre-trained) | $0.777$ | $0.767$ | $0.695$ | $0.765$ | $-$ |

### A.4 Intervention Procedure Additional Details

Formally, this procedure consists of the following steps:

- 1.
Given an input sequence $x=<x_{1},...,x_{t}>$ we first pass it through the model  as in regular inference while storing the activation values at all hidden layers, i.e  $h_{i}^{l}$ for all $1\leq i\leq t$, $1\leq l\leq N$.
- 2.
We calculate the saturation layer $l_{i}^{1}$ of the 1st token for each token $w_{i}$ in the text.
- 3.
We sample pairs of token indexes $i,j$  in the text that the satisfy the following conditions:
(a)
The distance between $i$ and $j$ is no more than 40 tokens, i.e. $|i-j|\leq 40$.
This is a precaution to minimize the effect of the difference in context on the model’s predictions after intervention.
(b)
The model’s top-1 prediction (in the final layer) for both indexes is the same token y, meaning $y=argmax(softmax(Eh_{i}^{N}))=argmax(softmax(Eh_{j}^{N}))$.
The goal here is to avoid a conflict in the top-1 predictions which could be a confounding factor.
(c)
There is a difference of at least 10 layers between the 1st token saturation layers of i and j, such that $|l_{i}^{1}-l_{j}^{1}|\leq 10$, to ensure that the change in saturation layer after intervention is significant.
For convenience’s sake we will assume in the remainder of the procedure description that $l_{i}^{1}<l_{j}^{1}$, i.e that the saturation layer of the first index in the pair is smaller then that of the second index (even though both cases are allowed by our conditions).
- 4.
We perform 11 additional forward passes, each time injecting the output from layer $l^{\prime}$ in range $[l_{i}^{1}-5,l_{i}^{1}+5]$ at position $i$ as input into layer $l^{\prime}+1$ at position j . The goal here is to to quantify the difference in effect between layers preceding the saturation event and those after it.
- 5.
We measure the causal effect of the intervention by calculating the percent of examples where the saturation layer of the 1st token after intervention $\tilde{l}_{j}^{1}$ is the layer on which we intervened, i.e. $\tilde{l}_{j}^{1}=l+1$.

For example, in the setting depicted in 4 we would take the indexes of the marked tokens ”wanted” and ”the” as our pair, where the original top-1 prediction in both is ”artist”. The top-1 saturation layer in the clean run for ”wanted” is layer 25, so we would inject activations from layers 20 to 30 one at a time as inputs into the corresponding subsequent layers in the run of token ”the” (i.e. layers 21 to 31), and check for each one if the injected layer became the new top-1 saturation layer after the intervention.

#### A.4.1 Intervention Procedure on ViT

To adapt the intervention procedure described in section 4.2 to ViT-L/16 and the image classification setting we made the following modifications:

- 1.
Since each image is processed independently by the model there is no need for two images to share a context, so the only requirements for two images to be chosen as a relevant pair were: a distance of at least 5 layers (instead of 10, since this model only has 24 total layers compared to GPT2-XL’s 48) between the top-1 saturation layers, and the same top-1 class prediction in the final layer.
- 2.
For each image, as in all experiments conducted on this model we only consider the prediction at index 0 corresponding to the [CLS] token in the input.
- 3.
We used embeddings from 3 layers before and 3 layers after the saturation layer (instead of 5, again due to the smaller number of layers) resulting in 7 total forward passes.

Figure 5 shows that the results for this model follow a similar step function pattern to the ones for GPT2, where injecting embeddings from the top-1 saturation layer or one of the subsequent layers causes the model to ”immediately” (at the injected layer) switch to the second task in a high percentage of cases, when compared to injecting embeddings from one of the layer before the top-1 saturation which almost never has the same effect.

#### A.4.2 Intervention Procedure on Whisper

We made the following adjustments to run the procedure described in section 4.2 on Whisper-large and 200 token pairs from randomly sampled 50 audios from the LibriSpeech dataset:

- 1.
Since the average audio in LibriSpeech is 10 seconds long there are not enough tokens in one sample to find relevant pairs, so we wave the requirement for a pair to share context and only leave two conditions: a distance of at least 5 layers (instead of 10, since this model only has 32 total layers compared to GPT2-XL’s 48) between the top-1 saturation layers, and the same top-1 prediction in the final layer.
- 2.
We used embeddings from 3 layers before and 3 layers after the saturation layer (instead of 5, again due to the smaller number of layers) resulting in 7 total forward passes.

Figure 5 shows that the results for this model follow a similar pattern to the other two models, even though the effect increases in the following layers after the saturation event.

### A.5 Additional Details for Token-Level Early Exit Measures Comparison

Figure: Figure 6: Performance-efficiency trade-off comparison of different confidence measures against a static baseline (where all layers are used for each token) and a local oracle measure (where the early exit is at the top-1 saturation layer). The graph shows softmax and state confidence measure results at different thresholds. Our method achieves the highest next-word prediction accuracy out of all early-exist methods while providing significant speedup compared to the baseline.
Refer to caption: extracted/5937591/figure_6_new.png

**Table 7: Softmax Response accuracy & speedup ratios at various confidence thresholds**
|  | Thresholds |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | 0.4 | 0.5 | 0.6 | 0.7 | 0.8 | 0.9 | 0.92 | 0.94 |
| Accuracy | $0.240$ | $0.270$ | $0.296$ | $0.317$ | $0.336$ | $0.353$ | $0.357$ | $0.359$ |
| Speedup Ratio | $1.830$ | $1.640$ | $1.491$ | $1.373$ | $1.269$ | $1.169$ | $1.148$ | $1.126$ |

**Table 8: Hidden-sate saturation accuracy & speedup ratios at various confidence thresholds**
|  | Thresholds |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | 0.986 | 0.988 | 0.989 | 0.99 | 0.991 | 0.992 | 0.993 | 0.994 | 0.995 |
| Accuracy | $0.256$ | $0.306$ | $0.333$ | $0.353$ | $0.367$ | $0.372$ | $0.374$ | $0.374$ | $0.375$ |
| Speedup Ratio | $1.496$ | $1.288$ | $1.197$ | $1.125$ | $1.073$ | $1.039$ | $1.019$ | $1.008$ | $1.003$ |

## Peer Reviews

confidence: 3
contribution: 4
initial_rating: 6
presentation: 2
questions: 1. I recommend to change the definition of "task" to other words like "process". The concept of "task transition" makes me feel like there is some generality in different tasks like summarization, QA, dialogues, etc.

2. The experiments on vision and speech transformers are great demonstrations to your claim on the generality of your findings but have no contribution to real applications like decoding acceleration. Maybe you can consider to remove them into appendix and enlarge your study on language model part.

3. I am very interested in whether such saturation event happens on all tokens in the context or just a few tokens? If it does not happen on all tokens, how you can deal with the prediction towards these non-saturation tokens?
soundness: 3
strengths: 1. The concept and research problem in this work is very novel. It significantly extends the range of saturation event to the top-k token level. 

2. The findings are very brute-force, which can be easily used for early-exit decoding for next token prediction acceleration without introducing much additional computation. And such decoding strategy is general and easily applied across all transformer based LLMs.
summary: This work expands the top-1 saturation event to top-k tokens and finds a significant phenomenon that there is an order law between the saturation events and the corresponding tokens' ranking. Additionally, such phenomenon is rooted in transformer architecture, which happens across all modality and even in untrained models. With the finding of such order law on the saturation events, an efficient decoding method is proposed for early-exit for next-token prediction.
weaknesses: 1. The evaluation of this method is limited in its size and targeted models. 60k tokens and 100 texts are a too small evaluation set size for a robust conclusion. GPT2-XL is also not well-trained and the experiments on Llama-3 is more recommended. If the saturation event for top-k tokens only happens at very late layers, then the acceleration ratio is not that ideal compared with GPT2-XL experiments. CNN summarization task is a very basic task for recent LLMs, while the benchmarks of MMLU, Hellaswag are more recommended for study and experiments.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: See the above weakness. The main concern is that the proposed method is quite heuristic and hand-crafted without enough supportive evidence. While the authors demonstrate the results across different modalities, it is difficult to evaluate the effectiveness of this method given the relatively low numbers.
soundness: 2
strengths: 1. This paper is well written with clear illustrations.
2. There are extensive experiments across different modalities, such as vision, language, and speech.
3. Compared with two baseline models, the proposed method demonstrates improved performance.
summary: This paper is to understand the inner workings of transformers to achieve more accurate and efficient predictions. Authors expand the concept of saturation events for top-k tokens, demonstrating that similar saturation events occur across language, vision, and speech models. The experiments show that it is possible to predict the current task from hidden layer embedding. Furthermore, authors use an intervention method to cause the model to swithc from one task to the next.
weaknesses: 1. Compared with Line 275 and L 276, the proposed method seems to be model-specific. While the results in Table 1 show the layer embeddings contain information about the task number, such information may only work for language, but not vision and speech.

2. in Line 472, why the second token's saturation layer is at least "7" layers before the output? The hypothesis seems to be hand-crafted without any supportive evidence.

3. In Table 2, the comparisons of different strategies are a little bit weak to support the claim. Is 40% accuracy a significant improvement compared to the baselines 35.9% and 37.5%? As these numbers are pretty low to have any real applications.

---

confidence: 4
contribution: 4
initial_rating: 8
presentation: 3
questions: Please see the weakness part. Highly appreciate if the author give some feedback.
soundness: 4
strengths: 1. The paper provides a fresh perspective on how Transformers process predictions beyond the top-1 token, which is a significant contribution to the field of model interpretability.
2. The study's scope extends across multiple modalities, enhancing the generalizability of the findings and demonstrating the robustness of the proposed mechanisms.
3. The authors back their claims with extensive experiments and provide empirical evidence supporting the task-transition hypothesis.
4. The paper not only has theoretic analysis but also explores practical applications, such as the early-exit strategy, which has potential implications for improving model efficiency and accuracy.
summary: This paper investigates the internal mechanisms of Transformers, particularly focusing on the computation performed after the top-1 prediction has been determined, a phenomenon referred to as the "saturation event." The authors expand the concept of saturation events to top-k tokens and demonstrate that these events occur in a ranked order across various modalities (language, vision, speech) and Transformer architectures. They propose a task-transition mechanism to explain this sequential saturation, where each task corresponds to predicting the k-th most probable token. The paper further shows that it is possible to predict the current task from hidden layer embeddings and to induce task transitions through interventions. Finally, the authors introduce a token-level early-exit strategy that improves performance and efficiency, outperforming existing methods.
weaknesses: This is a suggestion rather than a weakness. 

It would be great to discuss whether this is a fundamental solution for early exit problem. After all, it is ridiculous for us to let problems with all level of difficulties to go through all the layers. There must be a solution that significantly improve the inference efficiency of the current LLM through sparsity or early exit. Yet the solution proposed by this paper give only marginal improvement.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: (1) Table 1 shows different chance levels for each model (e.g., 25% for Whisper-large vs. 20% for GPT2-XL and ViT-L/16) Could the authors clarify the reason for these differences?

(2) In Figure 3, how did the authors handle cases where two top-ranked tokens reach saturation at the same layer?

(3) Following up, how were such cases handled during classifier training?

(4) In Table 1, how was accuracy calculated in these scenarios?

(5) typo: 400lines: l1(s1) < l2(s2) => l1(s1) < l1(s2)

(6) Could the authors provide a comparison with other early exit methods?
soundness: 3
strengths: The paper is written in a clear and understandable manner, with a well-defined approach and valuable findings that go beyond observation to demonstrate practical benefits. I believe this is an good research, and with a few additional points, it would be well-suited for acceptance at the conference.
summary: 1) This study extends the concept of saturation from only the top-1 token to multiple top-ranked tokens, providing deeper insights into the computational processes within Transformer models.
2) Experiments across diverse domains, including text, vision, and speech, demonstrate the broad applicability of this sequential saturation mechanism.
3) Beyond observing this phenomenon, the authors propose an early-exit algorithm based on their findings, presenting a practical approach to enhance computational efficiency in Transformer models.
weaknesses: If the paper claims that these findings are unique to Transformers (as the title suggests), it should demonstrate that (1) this phenomenon does not occur in other architectures and (2) it consistently appears in recent, state-of-the-art models. Providing this evidence would make the paper much more logically sound and robust.

The practical applicability of the experiments in Sections 5.1 and 5.2 feels somewhat limited; further validation could enhance their real-world relevance. (For example, as shown in A.5, softmax and state cannot outperform ours even at the minimum speedup, which makes the comparison less compelling.)

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: as above
soundness: 1
strengths: Strengths:
The paper emphasizes the importance of investigating layer-wise states transition. The study tackles an important and interesting research question.
summary: The paper explores hidden states of intermediate layers of transformer-based models by mapping them onto the vocabulary space to extract ranking over tokens and analyzing their changes over the layers. The authors claim to identify sequential saturation events for top-k tokens, a phenomenon observed across language, vision, and speech models. They propose a type of discrete transition occurs during decoding.
weaknesses: The hypothesis of “saturation events” is taken as granted without sufficient evidence. The mechanism in producing top-1 tokens in LLMs is influenced by various factors, including LLM architecture, contexts, and how an LLM reacts to an input. Based on practice shared by many colleagues in probing LLMs, transformers often alternate their top-1 token predictions, even in later layers, which undermines the claimed findings by this study. 

The scope of the experiment is limited in terms of both the number and types of LLMs and tasks. This raises concerns about the generality of the findings. It is important to investigate both NLU and NLG tasks on a diverse range of LLMs under different regimes (e.g., pre-trained, post-trained, decoder-only, encoder-decoder) to ensure comprehensive insights. Instead of limiting to a small-scale LLM like GPT2-XL, the authors may consider exploring state-of-the-art (SOTA) LLMs, such as the LLAMA series, to broaden the scope of their research and enhance the robustness of the conclusions.

The use of ranks and central tendency in Figure 3 is confusing (i.e., why averaging ranks and std in figure 3). There are existing statistic rank tests the authors may leverage. The claimed sequential saturation pattern should be convincingly demonstrated.

The practical application of intervention is unclear, and the results shown in table 2 are not statistically significant. When you choose "Highest accuracy", how do you calculate it? Is it based on EM?

Meta-review: This paper receives the mixed ratings of 8, 5, 3, 8, 8. In this paper, the authors introduce a concept of "sequential saturation" in Transformers, analyzing how top-k tokens are fixed layer-by-layer beyond the top-1 prediction. This paper provides evidence supporting that saturation of top-ranking tokens occurs sequentially in various Transformer architectures and modalities. Furthermore, a task-transition mechanism is introduced to explain this phenomenon, validated through interventions and probing experiments.

Strengths:
- The idea of sequential saturation is intriguing, expanding current understanding of Transformer behavior.
- Extensive experiments across text, vision, and speech modalities strengthen the claim of generalizability.
- The proposed applications demonstrate potential practical utility in improving Transformer efficiency.

Area of improvements:
- The concept of task transitions, while innovative, lacks a clear connection to practical modeling scenarios. The assumption that each token represents a discrete task oversimplifies real-world complexities.
- Evidence from untrained models, while theoretically insightful, weakens applicability to real-world, pre-trained settings.
- Reviewer u1oC noted significant discrepancies when attempting to reproduce key results, raising concerns about the robustness of the experiments. The reliance on specific datasets and hyperparameters was not sufficiently detailed in the main paper, making reproducibility challenging.
- While statistical metrics like Kendall’s tau and probing accuracies are provided, the lack of clear visual/conceptual explanations for task transitions weaken the interpretability of the claims.
- Early-exit strategy, demonstrate only incremental gains over baseline methods.

The paper explores an interesting and promising direction, offering an innovative perspective on Transformer dynamics. However, concerns regarding the model's realism and the reproducibility of results persist despite the rebuttal and discussion. We encourage the authors to address these issues comprehensively, as doing so will significantly strengthen the work for a future resubmission.

Decision: Reject