Original: R EVISITING O VER - SMOOTHING IN BERT FROM THE P ERSPECTIVE OF G RAPH
Revised: R EVISITING O VER - SMOOTHING IN BERT FROM THE P ERSPECTIVE OF G RAPH

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Recently over-smoothing phenomenon of Transformer-based models is observed in both vision and language ﬁelds.
Revised: Recently over-smoothing phenomenon of Transformer-based models is observed in both vision and language ﬁelds.

Original: However, no existing work has delved deeper to further investigate the main cause of this phenomenon.
Revised: However, no existing work has delved deeper to further investigate the main cause of this phenomenon.

Original: In this work, we make the attempt to analyze the over-smoothing problem from the perspective of graph, where such problem was ﬁrst discovered and explored.
Revised: In this work, we make the attempt to analyze the over-smoothing problem from the perspective of graph, where such problem was ﬁrst discovered and explored.

Original: Intuitively, the self-attention matrix can be seen as a normalized adjacent matrix of a corresponding graph.
Revised: Intuitively, the self-attention matrix can be seen as a normalized adjacent matrix of a corresponding graph.

Original: Based on the above connection, we provide some theoretical analysis and ﬁnd that layer normalization plays a key role in the over-smoothing issue of Transformer-based models.
Revised: Based on the above connection, we provide some theoretical analysis and ﬁnd that layer normalization plays a key role in the over-smoothing issue of Transformer-based models.

Original: Speciﬁcally, if the standard deviation of layer normalization is sufﬁciently large, the output of Transformer stacks will converge to a speciﬁc low-rank subspace and results in over-smoothing.
Revised: Speciﬁcally, if the standard deviation of layer normalization is sufﬁciently large, the output of Transformer stacks will converge to a speciﬁc low-rank subspace and results in over-smoothing.

Original: To alleviate the over-smoothing problem, we consider hierarchical fusion strategies, which combine the representations from different layers adaptively to make the output more diverse.
Revised: To alleviate the over-smoothing problem, we consider hierarchical fusion strategies, which combine the representations from different layers adaptively to make the output more diverse.

Original: Extensive experiment results on various data sets illustrate the effect of our fusion method.
Revised: Extensive experiment results on various data sets illustrate the effect of our fusion method.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Over the past few years, Transformer (Vaswani et al., 2017) has been widely used in various natural language processing (NLP) tasks, including text classiﬁcation (Wang et al., 2018a), text translation (Ott et al., 2018), question answering (Rajpurkar et al., 2016; 2018) and text generation (Brown et al., 2020).
Revised: Over the past few years, Transformer (Vaswani et al., 2017) has been widely used in various natural language processing (NLP) tasks, including text classiﬁcation (Wang et al., 2018a), text translation (Ott et al., 2018), question answering (Rajpurkar et al., 2016; 2018) and text generation (Brown et al., 2020).

Original: The recent application of Transformer in computer vision (CV) ﬁeld also demonstrate the potential capacity of Transformer architecture.
Revised: The recent application of Transformer in computer vision (CV) ﬁeld also demonstrate the potential capacity of Transformer architecture.

Original: For instance, Transformer variants have been successfully used for image classiﬁcation (Dosovitskiy et al., 2021), object detection (Carion et al., 2020) and semantic segmentation (Strudel et al., 2021).
Revised: For instance, Transformer variants have been successfully used for image classiﬁcation (Dosovitskiy et al., 2021), object detection (Carion et al., 2020) and semantic segmentation (Strudel et al., 2021).

Original: Three fundamental descendants from
Revised: Three fundamental descendants from

Original: Transformer include BERT (Devlin et al., 2019), RoBERTa
Revised: Transformer include BERT (Devlin et al., 2019), RoBERTa

Original: (Liu et al., 2019) and ALBERT (Lan et al., 2020), which achieve state-of-the-art performance on a wide range of NLP tasks.
Revised: (Liu et al., 2019) and ALBERT (Lan et al., 2020), which achieve state-of-the-art performance on a wide range of NLP tasks.

Original: Recently, Dong et al.
Revised: Recently, Dong et al.

Original: (2021) observes the “token uniformity” problem, which reduces the capacity of Transformer-based architectures by making all token representations identical.
Revised: (2021) observes the “token uniformity” problem, which reduces the capacity of Transformer-based architectures by making all token representations identical.

Original: They claim that pure self-attention (SAN) modules cause token uniformity, but they do not discuss whether the token uniformity problem still exists in Transformer blocks.
Revised: They claim that pure self-attention (SAN) modules cause token uniformity, but they do not discuss whether the token uniformity problem still exists in Transformer blocks.

Original: On the other hand, Gong et al.
Revised: On the other hand, Gong et al.

Original: (2021) observe the “over-smoothing” problem for ViT (Dosovitskiy et al., 2021), in that different input patches are mapped to a similar latent representation.
Revised: (2021) observe the “over-smoothing” problem for ViT (Dosovitskiy et al., 2021), in that different input patches are mapped to a similar latent representation.

Original: To prevent loss of information, they introduce additional loss functions to encourage diversity and successfully improve model performance by suppressing over-smoothing.
Revised: To prevent loss of information, they introduce additional loss functions to encourage diversity and successfully improve model performance by suppressing over-smoothing.

Original: Moreover, “overthinking” phenomenon, indicating that shallow representations are better than deep representations, also be observed in (Zhou et al., 2020; Kaya et al., 2019).
Revised: Moreover, “overthinking” phenomenon, indicating that shallow representations are better than deep representations, also be observed in (Zhou et al., 2020; Kaya et al., 2019).

Original: As discussed in Section 3, this phenomenon has some inherent connection with over-smoothing.
Revised: As discussed in Section 3, this phenomenon has some inherent connection with over-smoothing.

Original: In this paper, we use “over-smoothing” to unify the above issues, and refer this as the phenomenon that the model performance is deteriorated because different inputs are mapped to a similar representation.
Revised: In this paper, we use “over-smoothing” to unify the above issues, and refer this as the phenomenon that the model performance is deteriorated because different inputs are mapped to a similar representation.

Original: As the over-smoothing problem is ﬁrst studied in the graph neural network (GNN) literature (Li et al., 2018; Xu et al., 2018; Zhao & Akoglu, 2020), in this paper, we attempt to explore the cause of such  problem by building a relationship between Transformer blocks and graphs.
Revised: As the over-smoothing problem is ﬁrst studied in the graph neural network (GNN) literature (Li et al., 2018; Xu et al., 2018; Zhao & Akoglu, 2020), in this paper, we attempt to explore the cause of such ∗ Equal contribution. problem by building a relationship between Transformer blocks and graphs.

Original: Speciﬁcally, we consider the self-attention matrix as the normalized adjacency matrix of a weighted graph, whose nodes are the tokens in a sentence.
Revised: Speciﬁcally, we consider the self-attention matrix as the normalized adjacency matrix of a weighted graph, whose nodes are the tokens in a sentence.

Original: Furthermore, we consider the inherent connection between BERT and graph convolutional networks (Kipf & Welling, 2017).
Revised: Furthermore, we consider the inherent connection between BERT and graph convolutional networks (Kipf & Welling, 2017).

Original: Inspired by the over-smoothing problem in GNN, we study over-smoothing in BERT from a theoretical view via matrix projection.
Revised: Inspired by the over-smoothing problem in GNN, we study over-smoothing in BERT from a theoretical view via matrix projection.

Original: As opposed to Dong et al.
Revised: As opposed to Dong et al.

Original: (2021), where the authors claim that layer normalization is irrelevant to over-smoothing, we ﬁnd that layer normalization (Ba et al., 2016) plays an important role in over-smoothing.
Revised: (2021), where the authors claim that layer normalization is irrelevant to over-smoothing, we ﬁnd that layer normalization (Ba et al., 2016) plays an important role in over-smoothing.

Original: Speciﬁcally, we theoretically prove that, if the standard deviation in layer normalization is sufﬁciently large, the outputs of the Transformer stacks will converge to a low-rank subspace, resulting in over-smoothing.
Revised: Speciﬁcally, we theoretically prove that, if the standard deviation in layer normalization is sufﬁciently large, the outputs of the Transformer stacks will converge to a low-rank subspace, resulting in over-smoothing.

Original: Empirically, we verify that the conditions hold for a certain number of samples for a pre-trained and ﬁne-tuned BERT model (Devlin et al., 2019), which is consistent with our above observations.
Revised: Empirically, we verify that the conditions hold for a certain number of samples for a pre-trained and ﬁne-tuned BERT model (Devlin et al., 2019), which is consistent with our above observations.

Original: To alleviate the over-smoothing problem, we propose a hierarchical fusion strategy that adaptively fuses representations from different layers.
Revised: To alleviate the over-smoothing problem, we propose a hierarchical fusion strategy that adaptively fuses representations from different layers.

Original: Three fusion approaches are used: ( i ) Concat Fusion, ( ii ) Max Fusion, and ( iii ) Self-gate Fusion.
Revised: Three fusion approaches are used: ( i ) Concat Fusion, ( ii ) Max Fusion, and ( iii ) Gate Fusion.

Original: The proposed method reduces the similarity between tokens and outperforms BERT baseline on the GLUE (Wang et al., 2018a), SWAG (Zellers et al., 2018) and SQuAD (Rajpurkar et al., 2016; 2018) data sets.
Revised: The proposed method reduces the similarity between tokens and outperforms BERT baseline on the GLUE (Wang et al., 2018a), SWAG (Zellers et al., 2018) and SQuAD (Rajpurkar et al., 2016; 2018) data sets.

Original: In summary, the contributions of this paper are as follows: ( i )
Revised: In summary, the contributions of this paper are as follows: ( i )

Original: We develop the relationship between self-attention and graph for a better understanding of over-smoothing in BERT.
Revised: We develop the relationship between self-attention and graph for a better understanding of over-smoothing in BERT.

Original: ( ii ) We provide theoretical analysis on over-smoothing in the BERT model, and empirically verify the theoretical results.
Revised: ( ii ) We provide theoretical analysis on over-smoothing in the BERT model, and empirically verify the theoretical results.

Original: ( iii )
Revised: ( iii )

Original: We propose hierarchical fusion strategies that adaptively combine different layers to alleviate over-smoothing.
Revised: We propose hierarchical fusion strategies that adaptively combine different layers to alleviate over-smoothing.

Original: Extensive experimental results verify our methods’ effectiveness.
Revised: Extensive experimental results verify our methods’ effectiveness.

Original:  R ELATED W ORK 2. T RANSFORMER B LOCK AND S ELF -A TTENTION
Revised:  R ELATED W ORK 2. T RANSFORMER B LOCK AND S ELF -A TTENTION

Original: Transformer block is a basic component in Transformer model (Vaswani et al., 2017).
Revised: Transformer block is a basic component in Transformer model (Vaswani et al., 2017).

Original: Each Transformer block consists of a self-attention layer and a feed-forward layer.
Revised: Each Transformer block consists of a self-attention layer and a feed-forward layer.

Original: Let X ∈ R n × d be the input to a Transformer block, where n is the number of input tokens and d is the embedding size.
Revised: Let X ∈ R n × d be the input to a Transformer block, where n is the number of input tokens and d is the embedding size.

Original: The self-attention layer output can be written as:
Revised: The self-attention layer output can be written as:

Original: [Equation]
Revised: [Equation]

Original: where h is the number of heads, σ is the softmax function, and
Revised: where h is the number of heads, σ is the softmax function, and

Original: W Qk , W Kk , W Vk , W Ok ∈ R d × d h (where d h = d/h is the dimension of a single-head output) are weight matrices for the query, key, value, and output, respectively of the k th head.
Revised: W Qk , W Kk , W Vk , W Ok ∈ R d × d h (where d h = d/h is the dimension of a single-head output) are weight matrices for the query, key, value, and output, respectively of the k th head.

Original: In particular, the self-attention matrix
Revised: In particular, the self-attention matrix

Original: [Equation]
Revised: [Equation]

Original: in (1) plays a key role in the self-attention layer (Park et al., 2019;
Revised: in (1) plays a key role in the self-attention layer (Park et al., 2019;

Original: Gong et al., 2019; Kovaleva et al., 2019).
Revised: Gong et al., 2019; Kovaleva et al., 2019).

Original: As in (Yun et al., 2020; Shi et al., 2021; Dong et al., 2021), we drop the scale product 1 / √ d h to simplify analysis.
Revised: As in (Yun et al., 2020; Shi et al., 2021; Dong et al., 2021), we drop the scale product 1 / √ d h to simplify analysis.

Original: The feed-forward layer usually has two fully-connected (FC) layers with residual connection:
Revised: The feed-forward layer usually has two fully-connected (FC) layers with residual connection:

Original: [Equation]
Revised: [Equation]

Original: where W 1 ∈ R d × d ff , W 2 ∈ R d ff × d ( d ff is the size of the intermediate layer) are the weight matrices, and b 1 , b 2 are the biases.
Revised: where W 1 ∈ R d × d ff , W 2 ∈ R d ff × d ( d ff is the size of the intermediate layer) are the weight matrices, and b 1 , b 2 are the biases.

Original: Two layer normalization (Ba et al., 2016) operations are performed after the self-attention layer and fully-connected layer, respectively.
Revised: Two layer normalization (Ba et al., 2016) operations are performed after the self-attention layer and fully-connected layer, respectively.

Original: 2. O VER - SMOOTHING
Revised: 2. O VER - SMOOTHING

Original: In graph neural networks, over-smoothing refers to the problem that the performance deteriorates as representations of all the nodes become similar (Li et al., 2018; Xu et al., 2018; Huang et al., 2020).
Revised: In graph neural networks, over-smoothing refers to the problem that the performance deteriorates as representations of all the nodes become similar (Li et al., 2018; Xu et al., 2018; Huang et al., 2020).

Original: Its main cause is the stacked aggregation layer using the same adjacency matrix.
Revised: Its main cause is the stacked aggregation layer using the same adjacency matrix.

Original: Recently, several approaches have been proposed to alleviate the over-smoothing problem.
Revised: Recently, several approaches have been proposed to alleviate the over-smoothing problem.

Original: Xu et al.
Revised: Xu et al.

Original: (2018) propose a jumping knowledge network for better structure-aware representation, which ﬂexibly  leverages different neighborhood ranges.
Revised: (2018) propose a jumping knowledge network for better structure-aware representation, which ﬂexibly [Figure] leverages different neighborhood ranges.

Original: ResGCN (Li et al., 2019) adapts the residual connection and dilated convolution in the graph convolutional network (GCN), and successfully scales the GCN to 56 layers.
Revised: ResGCN (Li et al., 2019) adapts the residual connection and dilated convolution in the graph convolutional network (GCN), and successfully scales the GCN to 56 layers.

Original: Zhao & Akoglu (2020) propose PairNorm, a novel normalization layer, that prevents node embeddings from becoming too similar.
Revised: Zhao & Akoglu (2020) propose PairNorm, a novel normalization layer, that prevents node embeddings from becoming too similar.

Original: DropEdge (Rong et al., 2020; Huang et al., 2020) randomly removes edges from the input graph at each training epoch, and reduces the effect of over-smoothing.[Figure]
Revised: DropEdge (Rong et al., 2020; Huang et al., 2020) randomly removes edges from the input graph at each training epoch, and reduces the effect of over-smoothing.

Original: Unlike graph neural networks, over-smoothing in Transformer-based architectures has not been discussed in detail.
Revised: Unlike graph neural networks, over-smoothing in Transformer-based architectures has not been discussed in detail.

Original: Dong et al.
Revised: Dong et al.

Original: (2021) introduce the “token-uniformity” problem for self-attention, and show that skip connections and multi-layer perceptron can mitigate this problem.
Revised: (2021) introduce the “token-uniformity” problem for self-attention, and show that skip connections and multi-layer perceptron can mitigate this problem.

Original: However, Gong et al.
Revised: However, Gong et al.

Original: (2021) still observe over-smoothing on the Vision Transformers (Dosovitskiy et al., 2021).
Revised: (2021) still observe over-smoothing on the Vision Transformers (Dosovitskiy et al., 2021).

Original:  D OES O VER - SMOOTHING E XIST IN BERT?
Revised:  D OES O VER - SMOOTHING E XIST IN BERT?

Original: In this section, we ﬁrst explore the existence of over-smoothing in BERT, by measuring the similarity between tokens in each Transformer layer.
Revised: In this section, we ﬁrst explore the existence of over-smoothing in BERT, by measuring the similarity between tokens in each Transformer layer.

Original: Speciﬁcally, we use the token-wise cosine similarity (Gong et al., 2021) as our similarity measure:
Revised: Speciﬁcally, we use the token-wise cosine similarity (Gong et al., 2021) as our similarity measure:

Original: [Equation]
Revised: [Equation]

Original: where n is the number of tokens, h i and h j are two representations of different tokens, and (cid:107) · (cid:107) 2 is the Euclidean norm.
Revised: where n is the number of tokens, h i and h j are two representations of different tokens, and (cid:107) · (cid:107) 2 is the Euclidean norm.

Original: Following Dong et al.
Revised: Following Dong et al.

Original: (2021), we use WikiBio (Lebret et al., 2016) as input to the following Transformer-based models ﬁne-tuned on the SQuAD data set (Rajpurkar et al., 2018): ( i ) BERT (Devlin et al., 2019), ( ii ) RoBERTa (Liu et al., 2019) and ( iii ) ALBERT (Lan et al., 2020).
Revised: (2021), we use WikiBio (Lebret et al., 2016) as input to the following Transformer-based models ﬁne-tuned on the SQuAD data set (Rajpurkar et al., 2018)

Original: For comparison, all three models are stacked with 12 blocks.

Original: We calculate each CosSim for each data sample and show the average and standard derivation of CosSim values over all WikiBio data.

Original: In the ﬁgures, layer 0 represents original input token representation, and layer 1 - 12 represents the corresponding transformer layers.
Revised: In the ﬁgures, layer 0 represents original input token representation, and layer 1 - 12 represents the corresponding transformer layers.

Original: As shown in Figure 1(a), the original token representations are different from each other, while token similarities are high in the last layer.
Revised: As shown in Figure 1(a), the original token representations are different from each other, while token similarities are high in the last layer.

Original: For instance, the average token-wise cosine similarity of the last layer of ALBERT and RoBERTa are both larger than 90% .
Revised: For instance, the average token-wise cosine similarity of the last layer of ALBERT and RoBERTa are both larger than 90% .

Original: To illustrate the relationship between “over-thinking” and “over-smoothing”, we compare the tokenwise cosine similarity at each layer with the corresponding error rate.
Revised: To illustrate the relationship between “over-thinking” and “over-smoothing”, we compare the tokenwise cosine similarity at each layer with the corresponding error rate.

Original: As for the corresponding error rate of layer i , we use the representations from layer i as the ﬁnal output and ﬁne-tune the classiﬁer.
Revised: As for the corresponding error rate of layer i , we use the representations from layer i as the ﬁnal output and ﬁne-tune the classiﬁer.

Original: Following Zhou et al.
Revised: Following Zhou et al.

Original: (2020), we experiment with ALBERT (Lan et al., 2020) ﬁne-tuned on the
Revised: (2020), we experiment with ALBERT (Lan et al., 2020) ﬁne-tuned on the

Original: MRPC data set (Dolan & Brockett, 2005) and use their error rate results for convenience.
Revised: MRPC data set (Dolan & Brockett, 2005) and use their error rate results for convenience.

Original: As shown in Figure 1(b), layer 10 has the lowest cosine similarity and error rate.
Revised: As shown in Figure 1(b), layer 10 has the lowest cosine similarity and error rate.

Original: At layers 11 and 12 , the tokens have larger cosine similarities, making them harder to distinguish and resulting in the performance drop.
Revised: At layers 11 and 12 , the tokens have larger cosine similarities, making them harder to distinguish and resulting in the performance drop.

Original: Thus, “over-thinking” can be explained by “over-smoothing”.
Revised: Thus, “over-thinking” can be explained by “over-smoothing”.

Original: A direct consequence of over-smoothing is that the performance cannot be improved when the model gets deeper, since the individual tokens are no longer distinguishable.
Revised: A direct consequence of over-smoothing is that the performance cannot be improved when the model gets deeper, since the individual tokens are no longer distinguishable.

Original: To illustrate this, we increase the number of layers in BERT to 24 while keeping the other settings.
Revised: To illustrate this, we increase the number of layers in BERT to 24 while keeping the other settings.

Original: As shown in Figure 1(c), the  performance of vanilla BERT cannot improve as the model gets deeper.
Revised: As shown in Figure 1(c), the [Figure] performance of vanilla BERT cannot improve as the model gets deeper.

Original: In contrast, the proposed hierarchical fusion (as will be discussed in Section 6) consistently outperforms the baseline, and has better and better performance as the model gets deeper.
Revised: In contrast, the proposed hierarchical fusion (as will be discussed in Section 6) consistently outperforms the baseline, and has better and better performance as the model gets deeper.

Original: Based on these observations, we conclude that the over-smoothing problem still exists in BERT.[CLS] worth the effort [Figure] [SEP]
Revised: Based on these observations, we conclude that the over-smoothing problem still exists in BERT.

Original: [Figure]

Original:  R ELATIONSHIP BETWEEN S ELF -A TTENTION AND G RAPH
Revised:  R ELATIONSHIP BETWEEN S ELF -A TTENTION AND G RAPH

Original: Since over-smoothing is ﬁrst discussed in the graph neural network literature (Li et al., 2018; Zhao &
Revised: Since over-smoothing is ﬁrst discussed in the graph neural network literature (Li et al., 2018; Zhao &

Original: Akoglu, 2020), we attempt to understand its cause from a graph perspective in this section.
Revised: Akoglu, 2020), we attempt to understand its cause from a graph perspective in this section.

Original: 4. S ELF -A TTENTION VS R ES GCN
Revised: 4. S ELF -A TTENTION VS R ES GCN

Original: Given a Transformer block, construct a weighted graph G with the input tokens as nodes and exp( Q (cid:62) i K j ) as the ( i, j ) th entry of its adjacency matrix A .
Revised: Given a Transformer block, construct a weighted graph G with the input tokens as nodes and exp( Q (cid:62) i K j ) as the ( i, j ) th entry of its adjacency matrix A .

Original: By rewriting the self-attention matrix ˆ A in (2) as ˆ A
Revised: By rewriting the self-attention matrix ˆ A in (2) as ˆ A

Original: i,j = σ ( QK (cid:62) )
Revised: i,j = σ ( QK (cid:62) )

Original: i,j = exp( Q (cid:62) i K j ) / (cid:80) l exp( Q (cid:62) i K l ) , ˆ A can thus be viewed as G ’s normalized adjacency matrix (Von Luxburg, 2007).
Revised: i,j = exp( Q (cid:62) i K j ) / (cid:80) l exp( Q (cid:62) i K l ) , ˆ A can thus be viewed as G ’s normalized adjacency matrix (Von Luxburg, 2007).

Original: In other words, ˆ A =
Revised: In other words, ˆ A =

Original: D − 1 A , where D = diag ( d 1 , d 2 , . . .
Revised: D − 1 A , where D = diag ( d 1 , d 2 , . . .

Original: , d n ) and d i = (cid:80)
Revised: , d n ) and d i = (cid:80)

Original: j A i,j .
Revised: j A i,j .

Original: Figure 2 shows an example for the sentence “worth the effort to watch."
Revised: Figure 2 shows an example for the sentence “worth the effort to watch."

Original: from the SST-2 data set (Socher et al., 2013) processed by BERT.
Revised: from the SST-2 data set (Socher et al., 2013) processed by BERT.

Original: Note that graph convolutional network combined with residual connections (ResGCN) (Kipf &
Revised: Note that graph convolutional network combined with residual connections (ResGCN) (Kipf &

Original: Welling, 2017) can be expressed as follows.
Revised: Welling, 2017) can be expressed as follows.

Original: [Equation]
Revised: [Equation]

Original: which has the similar form with the self-attention layer in Eq.
Revised: which has the similar form with the self-attention layer in Eq.

Original: By comparing self-attention module with ResGCN, we have the following observations: (i) Since A i,j (cid:54) =
Revised: By comparing self-attention module with ResGCN, we have the following observations: (i) Since A i,j (cid:54) =

Original: A j,i in general, G in self-attention is a directed graph; (ii) ˆ A
Revised: A j,i in general, G in self-attention is a directed graph; (ii) ˆ A

Original: = D − 1 A in self-attention is the random walk normalization (Chung &
Revised: = D − 1 A in self-attention is the random walk normalization (Chung &

Original: Graham, 1997), while GCN usually uses the symmetric normalization version ˆ A
Revised: Graham, 1997), while GCN usually uses the symmetric normalization version ˆ A

Original: =
Revised: =

Original: D − 1 / 2 AD − 1 / 2 ; (iii)
Revised: D − 1 / 2 AD − 1 / 2 ; (iii)

Original: The attention matrices constructed at different Transformer layers are different, while in typical graphs, the adjacency matrices are usually static.
Revised: The attention matrices constructed at different Transformer layers are different, while in typical graphs, the adjacency matrices are usually static.

Original: 4. U NSHARED A TTENTION M ATRIX VS S HARED A TTENTION M ATRIX
Revised: 4. U NSHARED A TTENTION M ATRIX VS S HARED A TTENTION M ATRIX

Original: As discussed in Section 2.2, over-smoothing in graph neural networks is mainly due to the repeated aggregation operations using the same adjacency matrix.
Revised: As discussed in Section 2.2, over-smoothing in graph neural networks is mainly due to the repeated aggregation operations using the same adjacency matrix.

Original: To compare the self-attention matrices ( ˆ A ’s) at different Transformer layers, we ﬁrst ﬂatten the multi-head attention and then measure the cosine similarity between ˆ A ’s at successive layers.
Revised: To compare the self-attention matrices ( ˆ A ’s) at different Transformer layers, we ﬁrst ﬂatten the multi-head attention and then measure the cosine similarity between ˆ A ’s at successive layers.

Original: Experiment is performed with BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019) and ALBERT(Lan et al., 2020) on the
Revised: Experiment is performed with BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019) and ALBERT

Original:  WikiBio data set (Lebret et al., 2016). 
Revised: (Lan et al., 2020) on the WikiBio data set (Lebret et al., 2016). [Table]

Original: Figure 3 shows the cosine similarities obtained.
Revised: Figure 3 shows the cosine similarities obtained.

Original: As can be seen, the similarities at the last few[Table] layers are high, 2 while those at the ﬁrst few layers are different from each other.
Revised: As can be seen, the similarities at the last few layers are high, 2 while those at the ﬁrst few layers are different from each other.

Original: In other words, the attention patterns at the ﬁrst few layers are changing, and become stable at the upper layers. 
Revised: In other words, the attention patterns at the ﬁrst few layers are changing, and become stable at the upper layers. layer.

Original: In the following, we focus on BERT and explore how many layers can share the same self-attention matrix.
Revised: In the following, we focus on BERT and explore how many layers can share the same selfattention matrix.

Original: Note that this is different from ALBERT, which shares model parameters instead of attention matrices.
Revised: Note that this is different from ALBERT, which shares model parameters instead of attention matrices.

Original: Results are shown in Table 1.
Revised: Results are shown in Table 1.

Original: As can be seen, sharing attention matrices among the lastlayers (i.e., layers 5-12) does not harm model performance.
Revised: As can be seen, sharing attention matrices among the last 8 layers (i.e., layers 512) does not harm model performance.

Original: This is consistent with the observation in Figure 3.
Revised: This is consistent with the observation in Figure 3.

Original: Note that sharing attention matrices not only reduces the number of parameters in the self-attention module, but also makes the model more efﬁcient by reducing the computations during training and inference.
Revised: Note that sharing attention matrices not only reduces the number of parameters in the selfattention module, but also makes the model more efﬁcient by reducing the computations during training and inference.

Original: As shown in Table 1, BERT (5-12) reduces 44 .
Revised: As shown in Table 1, BERT (5-12) reduces 44 .

Original: 4% FLOPs in the self-attention modules compared with the vanilla BERT, while still achieving comparable average GLUE scores.
Revised: 4% FLOPs in the selfattention modules compared with the vanilla BERT, while still achieving comparable average GLUE scores.

Original:  O VER - SMOOTHING IN BERT
Revised:  O VER - SMOOTHING IN BERT

Original: In this section, we analyze the over-smoothing problem in BERT theoretically, and then verify the result empirically.
Revised: In this section, we analyze the over-smoothing problem in BERT theoretically, and then verify the result empirically.

Original: 5. T HEORETICAL A NALYSIS
Revised: 5. T HEORETICAL A NALYSIS

Original: Our analysis is based on matrix projection.
Revised: Our analysis is based on matrix projection.

Original: We deﬁne a subspace M , in which each row vector of the element in this subspace is identical.
Revised: We deﬁne a subspace M , in which each row vector of the element in this subspace is identical.

Original: Deﬁnition 1.
Revised: Deﬁnition 1.

Original: Deﬁne M := { Y ∈ R n × d | Y = eC , C ∈ R 1 × d } as a subspace in R n × d , where e = [1 , 1 , . .
Revised: Deﬁne M := { Y ∈ R n × d | Y = eC , C ∈ R 1 × d } as a subspace in R n × d , where e = [1 , 1 , . .

Original: , 1] (cid:62) ∈ R n × 1 , n is the number of tokens and d is the dimension of token representation.
Revised: , 1] (cid:62) ∈ R n × 1 , n is the number of tokens and d is the dimension of token representation.

Original: Each Y in subspace M suffers from the over-smoothing issue since the representation of each token is C , which is the same with each other.
Revised: Each Y in subspace M suffers from the over-smoothing issue since the representation of each token is C , which is the same with each other.

Original: We deﬁne the distance between matrix H ∈ R n × d and M as d M ( H ) :
Revised: We deﬁne the distance between matrix H ∈ R n × d and M as d M ( H ) :

Original: = min Y ∈M (cid:107) H − Y (cid:107) F , where (cid:107) · (cid:107) F is the Frobenius norm.
Revised: = min Y ∈M (cid:107) H − Y (cid:107) F , where (cid:107) · (cid:107) F is the Frobenius norm.

Original: Next, we investigate the distance between the output of layer l and subspace M .
Revised: Next, we investigate the distance between the output of layer l and subspace M .

Original: We have the following Lemma.
Revised: We have the following Lemma.

Revised: [Figure]

Revised: [Equation]

Revised: ℳ

Revised: [Equation]

Original: Lemma 1.
Revised: Lemma 1.

Original: For self-attention matrix ˆ A , any H , B ∈ R n × d and α 1 , α 2 ≥ 0 , we have:
Revised: For self-attention matrix ˆ A , any H , B ∈ R n × d and α 1 , α 2 ≥ 0 , we have:

Original: [Equation]
Revised: [Equation]

Original: where λ max is the largest eigenvalue of ˆ A (cid:62) ( I − ee (cid:62) )
Revised: where λ max is the largest eigenvalue of ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A
Revised: ˆ A

Original: and s is the largest singular value of W .
Revised: and s is the largest singular value of W .

Original: Using Lemma 1, we have the following Theorem.
Revised: Using Lemma 1, we have the following Theorem.

Original: Theorem 2.
Revised: Theorem 2.

Original: For a BERT block with h heads, we have
Revised: For a BERT block with h heads, we have

Original: [Equation]
Revised: [Equation]

Original: [Figure]

Original: where v =
Revised: where v =

Original: (1 + s 2 )(1 + √ λhs ) /
Revised: (1 + s 2 )(1 + √ λhs ) /

Original: ( σ 1 σ 2 ) , s > 0 is the largest element of all singular values of all
Revised: ( σ 1 σ 2 ) , s > 0 is the largest element of all singular values of all

Original: W l , λ is the largest eigenvalue of all ˆ A (cid:62) ( I − ee (cid:62) )
Revised: W l , λ is the largest eigenvalue of all ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A for each self-attention matrix ˆ A , and σ 1 , σare the minimum standard deviation for two layer normalization operations.
Revised: ˆ A for each self-attention matrix ˆ A , and σ 1 , σare the minimum standard deviation for two layer normalization operations.

Original: Proof is in Appendix A. Theorem 2 shows that if v < 1 (i.e., σ 1 σ 2 > (1+ s 2 )(1+ √ λhs ) ), the output of layer l + 1 will be closer to M than the output of layer l .
Revised: Proof is in Appendix A. Theorem 2 shows that if v < 1 (i.e., σ 1 σ 2 > (1+ s 2 )(1+ √ λhs ) ), the output of layer l + 1 will be closer to M than the output of layer l .

Original: An illustration of Theorem 2 is shown in
Revised: An illustration of Theorem 2 is shown in

Original: Figure 4.
Revised: Figure 4.

Original: H 0 is the graph corresponding to the input layer.
Revised: H 0 is the graph corresponding to the input layer.

Original: Initially, the token representations are very different (indicated by the different colors of the nodes).
Revised: Initially, the token representations are very different (indicated by the different colors of the nodes).

Original: Recursively, H l will converge towards to subspace M if v < 1 and all representations are the same, resulting in over-smoothing.
Revised: Recursively, H l will converge towards to subspace M if v < 1 and all representations are the same, resulting in over-smoothing.

Original: Remark Though we only focus on the case v < 1 , over-smoothing may still exist if v ≥ 1 .
Revised: Remark Though we only focus on the case v < 1 , over-smoothing may still exist if v ≥ 1 .

Original: As can be seen, layer normalization plays an important role for the convergence rate v .
Revised: As can be seen, layer normalization plays an important role for the convergence rate v .

Original: Interestingly,
Revised: Interestingly,

Original: Dong et al.
Revised: Dong et al.

Original: (2021) claim that layer normalization plays no roles for token uniformity, which seems to conﬂict with the conclusion in Theorem 2.
Revised: (2021) claim that layer normalization plays no roles for token uniformity, which seems to conﬂict with the conclusion in Theorem 2.

Original: However, note that the matrix rank cannot indicate similarity between tokens completely because matrix rank is discrete while similarity is continuous.
Revised: However, note that the matrix rank cannot indicate similarity between tokens completely because matrix rank is discrete while similarity is continuous.

Original: For instance, given two token embeddings
Revised: For instance, given two token embeddings

Original: h i and h j , the matrix [ h i , h j ] (cid:62) has rank 2 only if h i (cid:54) =
Revised: h i and h j , the matrix [ h i , h j ] (cid:62) has rank 2 only if h i (cid:54) =

Original: h j .
Revised: h j .

Original: In contrast, the consine similarity between tokens is
Revised: In contrast, the consine similarity between tokens is

Original: [Figure]

Original: [Equation]
Revised: [Equation]

Original: As discussed in Section 4.1, GCN use the symmetric normalization version ˆ A
Revised: As discussed in Section 4.1, GCN use the symmetric normalization version ˆ A

Original: =
Revised: =

Original: D − 1 / 2 AD − 1 / 2 , resulting in the target subspace M (cid:48) :
Revised: D − 1 / 2 AD − 1 / 2 , resulting in the target subspace M (cid:48) :

Original: = { Y ∈ R n × d | Y =
Revised: = { Y ∈ R n × d | Y =

Original: D 1 / 2 eC , C ∈ R 1 × d } is dependent with adjacent matrix (Huang et al., 2020).
Revised: D 1 / 2 eC , C ∈ R 1 × d } is dependent with adjacent matrix (Huang et al., 2020).

Original: In contrast, our subspace M is independent of ˆ A thanks to its random walk normalization.
Revised: In contrast, our subspace M is independent of ˆ A thanks to its random walk normalization.

Original: Thus, Theorem 2 can be applied to the vanilla BERT even though its attention matrix ˆ A is not similar.
Revised: Thus, Theorem 2 can be applied to the vanilla BERT even though its attention matrix ˆ A is not similar.

Original: 5. E MPIRICAL V ERIFICATION
Revised: 5. E MPIRICAL V ERIFICATION

Original: Theorem 2 illustrates that the magnitude of σ 1 σ 2 is important for over-smoothing issue.
Revised: Theorem 2 illustrates that the magnitude of σ 1 σ 2 is important for over-smoothing issue.

Original: If σ 1 σ 2 > (1+ s 2 )(1+ √ λhs ) , the output will be closer to subspace M suffered from over-smoothing.
Revised: If σ 1 σ 2 > (1+ s 2 )(1+ √ λhs ) , the output will be closer to subspace M suffered from over-smoothing.

Original: Since s is usually small due to the (cid:96) 2 -penalty during training (Huang et al., 2020), we neglect the effect of s and compare σ 1 σ 2 with 1 for simplicity.
Revised: Since s is usually small due to the (cid:96) 2 -penalty during training (Huang et al., 2020), we neglect the effect of s and compare σ 1 σ 2 with 1 for simplicity.

Original: To verify the theoretical results, we visualize σ 1 σ 2 in different ﬁne-tuned BERT models.
Revised: To verify the theoretical results, we visualize σ 1 σ 2 in different ﬁne-tuned BERT models.

Original: Speciﬁcally, we take the development set data of STS-B (Cer et al., 2017),
Revised: Speciﬁcally, we take the development set data of STS-B (Cer et al., 2017),

Original:  CoLA (Warstadt et al., 2019), SQuAD (Rajpurkar et al., 2016) as input to the ﬁne-tuned models and visualize the distribution of σ 1 σ 2 at the last layer using kernel density estimation (Rosenblatt, 1956).
Revised: [Figure] CoLA (Warstadt et al., 2019), SQuAD (Rajpurkar et al., 2016) as input to the ﬁne-tuned models and visualize the distribution of σ 1 σ 2 at the last layer using kernel density estimation (Rosenblatt, 1956).

Original: Results are shown in Figure 5.
Revised: Results are shown in Figure 5.

Original: As can be seen, the distributions of σ 1 σ 2 can be very different across data sets.
Revised: As can be seen, the distributions of σ 1 σ 2 can be very different across data sets.

Original: For STS-B (Cer et al., 2017), σ 1 σ 2 of all data is larger than 1 , which means that over-smoothing is serious for this data set.
Revised: For STS-B (Cer et al., 2017), σ 1 σ 2 of all data is larger than 1 , which means that over-smoothing is serious for this data set.

Original: For CoLA (Warstadt et al., 2019) and SQuAD (Rajpurkar et al., 2016), there also exists a fraction of samples satisfying σ 1 σ 2 > 1 .
Revised: For CoLA (Warstadt et al., 2019) and SQuAD (Rajpurkar et al., 2016), there also exists a fraction of samples satisfying σ 1 σ 2 > 1 .

Original:  M ETHOD
Revised:  M ETHOD

Original: From our proof in Appendix A, we ﬁgure out that the main reason is the post-normalization scheme in BERT.
Revised: From our proof in Appendix A, we ﬁgure out that the main reason is the post-normalization scheme in BERT.

Original: In comparison, to train a 1000-layer GCN, Li et al.
Revised: In comparison, to train a 1000-layer GCN, Li et al.

Original: (2021) instead apply pre-normalization with skip connections to ensure v > 1 .
Revised: (2021) instead apply pre-normalization with skip connections to ensure v > 1 .

Original: However, the performance of pre-normalization is not better than post-normalization for layer normalization empirically (He et al., 2021).
Revised: However, the performance of pre-normalization is not better than post-normalization for layer normalization empirically (He et al., 2021).

Original: In this section, we[Figure] preserve the post-normalization scheme and propose a hierarchical fusion strategy to alleviate the over-smoothing issue.
Revised: In this section, we preserve the post-normalization scheme and propose a hierarchical fusion strategy to alleviate the over-smoothing issue.

Original: Speciﬁcally, since only deep layers suffer from the over-smoothing issue, we allow the model select representations from both shallow layers and deep layers as ﬁnal output.
Revised: Speciﬁcally, since only deep layers suffer from the over-smoothing issue, we allow the model select representations from both shallow layers and deep layers as ﬁnal output.

Original: 6. H IERARCHICAL F USION S TRATEGY
Revised: 6. H IERARCHICAL F USION S TRATEGY

Original: Here, we consider three hierarchical fusion strategies with different levels to aggregate token representations across different layers.

Original: Concat Fusion We ﬁrst consider a simple and direct layer-wise Concat Fusion approach.
Revised: Concat Fusion We ﬁrst consider a simple and direct layer-wise Concat Fusion approach.

Original: Considering a L -layer model, we ﬁrst concatenate the representations H k from each layer k to generate a matrix [ H 1 , H 2 , . . .
Revised: Considering a L -layer model, we ﬁrst concatenate the representations H k from each layer k to generate a matrix [ H 1 , H 2 , . . .

Original: , H L ] and then apply a linear mapping to generate the ﬁnal representation (cid:80)
Revised: , H L ] and then apply a linear mapping to generate the ﬁnal representation (cid:80)

Original: Lk
Revised: Lk

Original: =1 α k H k .
Revised: =1 α k H k .

Original: Here { α k } are model parameters independent with inputs.
Revised: Here { α k } are model parameters independent with inputs.

Original: Since this scheme requires preserving feature maps from all layers, the memory cost will be huge as the model gets deep.
Revised: Since this scheme requires preserving feature maps from all layers, the memory cost will be huge as the model gets deep.

Original: Max Fusion Inspired by the idea of the widely adopted max-pooling mechanism,element-wise Max Fusion strategy is considered. In practice, we construct the ﬁnal output by taking the maximum value across all layers for each dimension of the representation.
Revised: Max Fusion Inspired by the idea of the widely adopted max-pooling mechanism, we construct the ﬁnal output by taking the maximum value across all layers for each dimension of the representation.

Original: Max Fusion is an adaptive fusion mechanism since the model can dynamically decide the important layer for each element in the representation.
Revised: Max Fusion is an adaptive fusion mechanism since the model can dynamically decide the important layer for each element in the representation.

Original: Max Fusion is the most ﬂexible strategy, since it does not require learning any additional parameters and is more efﬁcient in terms of speed and memory.
Revised: Max Fusion is the most ﬂexible strategy, since it does not require learning any additional parameters and is more efﬁcient in terms of speed and memory.

Original: Self-gate Fusion Gate mechanism is commonly used for information propagation in natural language processing ﬁeld (Cho et al., 2014).
Revised: Max Fusion Gate mechanism is commonly used for information propagation in natural language processing ﬁeld (Cho et al., 2014).

Original: To exploit the advantages from different semantic levels, we propose a vertical self-gate fusion module, which predicts the respective importance of token-wise representations from different layers and aggregate them adaptively.
Revised: To exploit the advantages from different semantic levels, we propose a vertical gate fusion module, which predicts the respective importance of token-wise representations from different layers and aggregate them adaptively.

Original: Given token representations { H tk } , where t denotes the token index and k denotes the layer index, the ﬁnal representation for token t is calculated by:
Revised: Given token representations { H tk } , where t denotes the token index and k denotes the layer index, the ﬁnal representation for token t is calculated by (cid:80) Lk

Original: [Equation]{+=
 I tk · H tk , where I t 1 , I t 2 , . . . , I tL = softmax ( g ( H t 1 ) , g ( H t 2 ) , . . , g ( H tL )) .+}
Revised: {+=
 I tk · H tk , where I t 1 , I t 2 , . . . , I tL = softmax ( g ( H t 1 ) , g ( H t 2 ) , . . , g ( H tL )) .+}

Original: where L is the number of layers and the self-gate function g ( · ) is a fully-connected (FC) layer, which relies on the word representation itself in respective layers to predict its importance scores.
Revised: Here L is the number of layers and the gate function g ( · ) is a fully-connected (FC) layer, which relies on the word representation itself in respective layers to predict its importance scores.

Original: Note that the self-gate module is token-wise adaptive and the importance score is depend on the token representation itself.

Original: The weights of the self-gate function g ( · ) are shared across different layers.
Revised: The weights of the gate function g ( · ) are shared across different layers.

Original: Even though Concat Fusion and Max Fusion have been investigated in the graph ﬁeld (Xu et al., 2018), their effectiveness for pre-trained language model have not yet been explored.
Revised: Even though Concat Fusion and Max Fusion have been investigated in the graph ﬁeld (Xu et al., 2018), their effectiveness for pre-trained language model have not yet been explored.

Original: Besides, since the layer-wise Concat Fusion and element-wise Max Fusion lack the ability to generate token representations according to each token’s speciﬁcity, we further propose the token-wise Self-gate Fusion for adapting fusion to the language scenario. 
Revised: Besides, since the layer-wise Concat Fusion and element-wise Max Fusion lack the ability to generate token representations according to each token’s speciﬁcity, we further propose the token-wise Gate Fusion for adapting fusion to the language scenario. [Table]

Original: 6. E XPERIMENT R ESULTS
Revised: E XPERIMENT R ESULTS

Original: The BERT model is stacked with 12 Transformer blocks (Section 2.1) with the following hyperparameters: number of tokens n = 128 , number of self-attention heads h = 12 , and hidden layer size[Table] d = 768 .
Revised: The BERT model is stacked with 12 Transformer blocks (Section 2.1) with the following hyperparameters: number of tokens n = 128 , number of self-attention heads h = 12 , and hidden layer size d = 768 .

Original: As for the feed-forward layer, we set the ﬁlter size d ff to 3072 as in Devlin et al.
Revised: As for the feed-forward layer, we set the ﬁlter size d ff to 3072 as in Devlin et al.

Original: We perform pre-training and ﬁne-tuning paradigm and all experiments are performed on NVIDIA Tesla V100 GPUs.
Revised: [Table] experiments are performed on NVIDIA Tesla V100 GPUs.

Original: 6.2. D ATA AND SETTINGS
Revised: 6.2. D ATA AND SETTINGS

Original: Pre-training For the setting in pre-training phase, we mainly follows BERT paper (Devlin et al., 2019).
Revised: Pre-training For the setting in pre-training phase, we mainly follows BERT paper (Devlin et al., 2019).

Original: Our pre-training tasks are vanilla masked language modeling (MLM) and next sentence prediction (NSP).
Revised: Our pre-training tasks are vanilla masked language modeling (MLM) and next sentence prediction (NSP).

Original: The pre-training datasets are English BooksCorpus (Zhu et al., 2015) and Wikipedia (Devlin et al., 2019)
Revised: The pre-training datasets are English BooksCorpus (Zhu et al., 2015) and Wikipedia (Devlin et al., 2019)

Original: ( 16 G in total).
Revised: ( 16 G in total).

Original: The WordPiece embedding (Wu et al., 2016) and the dictionary containing 30 , 000 tokens in (Devlin et al., 2019) are still used in our paper.
Revised: The WordPiece embedding (Wu et al., 2016) and the dictionary containing 30 , 000 tokens in (Devlin et al., 2019) are still used in our paper.

Original: To pre-process text, we use the special token
Revised: To pre-process text, we use the special token

Original: [CLS] as the ﬁrst token of each sequence and [SEP] to separate sentences in a sequence.
Revised: [CLS] as the ﬁrst token of each sequence and [SEP] to separate sentences in a sequence.

Original: The pre-training is performed for 40 epochs.
Revised: The pre-training is performed for 40 epochs.

Original: Fine-tuning In the ﬁne-tuning phase, we perform downstream experiments on the GLUE (Wang et al., 2018a), SWAG (Zellers et al., 2018) and SQuAD (Rajpurkar et al., 2016; 2018) benchmarks.
Revised: Fine-tuning In the ﬁne-tuning phase, we perform downstream experiments on the GLUE (Wang et al., 2018a), SWAG (Zellers et al., 2018) and SQuAD (Rajpurkar et al., 2016; 2018) benchmarks.

Original: GLUE is a natural language understanding benchmark, which includes three categories tasks: (i) single-sentence tasks (CoLA and SST-2); (ii) similarity and paraphrase tasks (MRPC, QQP and
Revised: GLUE is a natural language understanding benchmark, which includes three categories tasks: (i) single-sentence tasks (CoLA and SST-2); (ii) similarity and paraphrase tasks (MRPC, QQP and

Original: STS-B); (iii) inference tasks (MNLI, QNLI and RTE).
Revised: STS-B); (iii) inference tasks (MNLI, QNLI and RTE).

Original: For MNLI task, we experiment on both the matched (MNLI-m) and mismatched (MNLI-mm) versions.
Revised: For MNLI task, we experiment on both the matched (MNLI-m) and mismatched (MNLI-mm) versions.

Original: The SWAG data set is for grounded commonsense inference, while SQuAD is a task for question answering.
Revised: The SWAG data set is for grounded commonsense inference, while SQuAD is a task for question answering.

Original: In SQuAD v1.1 (Rajpurkar et al., 2016), the answers are included in the context.
Revised: In SQuAD v1.1 (Rajpurkar et al., 2016), the answers are included in the context.

Original: SQuAD v2.0 (Rajpurkar et al., 2018) is more challenge than SQuAD v1.0, in which some answers are not included in the context.
Revised: SQuAD v2.0 (Rajpurkar et al., 2018) is more challenge than SQuAD v1.0, in which some answers are not included in the context.

Original: Following BERT (Devlin et al., 2019), we report accuracy for MNLI, QNLI, RTE, SST-2 tasks, F1 score for QQP and
Revised: Following BERT (Devlin et al., 2019), we report accuracy for MNLI, QNLI, RTE, SST-2 tasks, F1 score for QQP and

Original: MRPC, Spearman correlation for STS-B, and Matthews correlation for CoLA.
Revised: MRPC, Spearman correlation for STS-B, and Matthews correlation for CoLA.

Original: For SWAG task, we use accuracy for evaluation.
Revised: For SWAG task, we use accuracy for evaluation.

Original: For SQuAD v1.1 and v2.0, we report the Exact Match (EM) and F scores.
Revised: For SQuAD v1.1 and v2.0, we report the Exact Match (EM) and F scores.

Original: Descriptions of the data sets and details of other hyper-parameter settings are in Appendix B and in Appendix C, respectively.
Revised: Descriptions of the data sets and details of other hyper-parameter settings are in Appendix B and in Appendix C, respectively.

Original: 6.2. RESULTS AND ANALYSIS
Revised: 6.2. RESULTS AND ANALYSIS

Original: [Table]
Revised: [Table]

Original: Since BERT (Devlin et al., 2019) and RoBERTa (Liu et al., 2019) share the same architecture and the only difference is data resource and training steps, here we mainly evaluate our proposed method on BERT and ALBERT (Lan et al., 2020).
Revised: Since BERT (Devlin et al., 2019) and RoBERTa (Liu et al., 2019) share the same architecture and the only difference is data resource and training steps, here we mainly evaluate our proposed method on BERT and ALBERT (Lan et al., 2020).

Original: Results on the GLUE benchmark are shown in Table 2, while results on SWAG and
Revised: Results on the GLUE benchmark are shown in Table 2, while results on SWAG and

Original: SQuAD are illustrated in Table 3.
Revised: SQuAD are illustrated in Table 3.

Original: For SQuAD task, in contrast to BERT which (Devlin et al., 2019) utilize the augmented training data during ﬁne-tuning phase, we only ﬁne-tune our model on the standard SQuAD data set.
Revised: For SQuAD task, in contrast to BERT which (Devlin et al., 2019) utilize the augmented training data during ﬁne-tuning phase, we only ﬁne-tune our model on the standard SQuAD data set.

Original: As can be seen, our proposed fusion strategies also perform better than baselines on various tasks consistently.
Revised: As can be seen, our proposed fusion strategies also perform better than baselines on various tasks consistently.

Original: Following the previous over-smoothing measure, we visualize the token-wise cosine similarity in each layer.
Revised: Following the previous over-smoothing measure, we visualize the token-wise cosine similarity in each layer.

Original: Here we perform visualization on the same data sets as Section 5.2 and the results are shown in Figure 6.
Revised: Here we perform visualization on the same data sets as Section 5.2 and the results are shown in Figure 6.

Original: Since the ﬁnal output of fusion approach is aggregated by representations from all 12 layers, we omit the similarity at 12 th layer and show the similarity at the ﬁnal output instead for fusion strategy.

Original: For all three data sets, the cosine similarity has a drop in the last layer compared
Revised: For all three data sets, the cosine similarity has a drop in the last layer compared

Original: [Figure]
Revised: [Figure]

Original: with baseline.
Revised: with baseline.

Original: It’s remarkable that the similarity drop is the most obvious in STS-B (Cer et al., 2017), which is consistent with our empirical veriﬁcation that STS-B’s σ 1 σ 2 is the largest in Section 5.2.
Revised: It’s remarkable that the similarity drop is the most obvious in STS-B (Cer et al., 2017), which is consistent with our empirical veriﬁcation that STS-B’s σ 1 σ 2 is the largest in Section 5.2.

Original: Since the representation of tokens from prior layers is not similar with each other, our fusion method alleviates the over-smoothing issue and improve the model performance at the same time.
Revised: Since the representation of tokens from prior layers is not similar with each other, our fusion method alleviates the over-smoothing issue and improve the model performance at the same time.

Original: To study the dynamic weights of fusion self-gate strategy, we visualize the importance weight I tk for each token t and for each layer k .
Revised: To study the dynamic weights of fusion gate strategy, we visualize the importance weight I tk for each token t and for each layer k .

Original: We randomly select three samples and the visualization results are illustrated in Figure 7.
Revised: We randomly select three samples and the visualization results are illustrated in Figure 7.

Original: Note that our self-gate strategy will reduce to vanilla model if representation from the last layer is selected for each token.
Revised: Note that our gate strategy will reduce to vanilla model if representation from the last layer is selected for each token.

Original: As can be seen, the weight distribution of different tokens is adaptively decided, illustrating that the vanilla BERT stacks model is not the best choice for all tokens.
Revised: As can be seen, the weight distribution of different tokens is adaptively decided, illustrating that the vanilla BERT stacks model is not the best choice for all tokens.

Original: The keywords which highly affect meaning of sentences (i.e. “women”, “water”, “ﬁsh” ) are willing to obtain more semantic representations from the deep layer, while for some simple words which appear frequently (i.e. “a”, “is” ), the features in shallow layers are preferred.
Revised: The keywords which highly affect meaning of sentences (i.e. “women”, “water”, “ﬁsh” ) are willing to obtain more semantic representations from the deep layer, while for some simple words which appear frequently (i.e. “a”, “is” ), the features in shallow layers are preferred.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we revisit the over-smoothing problem in BERT models.
Revised: In this paper, we revisit the over-smoothing problem in BERT models.

Original: Since this issue has been detailed discuss in graph learning ﬁeld, we ﬁrstly establish the relationship between BERT and graph for inspiration, and ﬁnd out that self-attention matrix can be shared among last few blocks without performance drop.
Revised: Since this issue has been detailed discuss in graph learning ﬁeld, we ﬁrstly establish the relationship between BERT and graph for inspiration, and ﬁnd out that self-attention matrix can be shared among last few blocks without performance drop.

Original: Inspired by over-smoothing discussion in graph convolutional network, we provide some theoretical analysis for BERT models and ﬁgure out the importance of layer normalization.
Revised: Inspired by over-smoothing discussion in graph convolutional network, we provide some theoretical analysis for BERT models and ﬁgure out the importance of layer normalization.

Original: Speciﬁcally, if the standard derivation of layer normalization is sufﬁciently large, the output will converge towards to a low-rank subspace.
Revised: Speciﬁcally, if the standard derivation of layer normalization is sufﬁciently large, the output will converge towards to a low-rank subspace.

Original: To alleviate the over-smoothing problem, we also propose a hierarchical fusion strategy to combine representations from different layers adaptively.
Revised: To alleviate the over-smoothing problem, we also propose a hierarchical fusion strategy to combine representations from different layers adaptively.

Original: Extensive experiment results on various data sets illustrate the effect of our fusion methods.
Revised: Extensive experiment results on various data sets illustrate the effect of our fusion methods.

Original: A P ROOF
Revised: A P ROOF

Original: Lemma 1.
Revised: Lemma 1.

Original: For self-attention matrix ˆ A , any H , B ∈ R n × d and α 1 , α 2 ≥ 0 , we have:
Revised: For self-attention matrix ˆ A , any H , B ∈ R n × d and α 1 , α 2 ≥ 0 , we have:

Original: [Equation]
Revised: [Equation]

Original: where λ max is the largest eigenvalue of ˆ A (cid:62) ( I − ee (cid:62) )
Revised: where λ max is the largest eigenvalue of ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A
Revised: ˆ A

Original: and s is the largest singular value of W .
Revised: and s is the largest singular value of W .

Original: Proof.
Revised: Proof.

Original: Here we only prove the last inequality (7), as the inequity is different from the theories in
Revised: Here we only prove the last inequality (7), as the inequity is different from the theories in

Original: GCN since ˆ A is not symmetric and shared in Transformer architecture.
Revised: GCN since ˆ A is not symmetric and shared in Transformer architecture.

Original: For the ﬁrst three inequalities, we refer to Oono & Suzuki (2020) and Huang et al.
Revised: For the ﬁrst three inequalities, we refer to Oono & Suzuki (2020) and Huang et al.

Original: Write HH (cid:62) =
Revised: Write HH (cid:62) =

Original: Q Ω Q (cid:62) for the eigin-decomposition of HH (cid:62) , where Q =
Revised: Q Ω Q (cid:62) for the eigin-decomposition of HH (cid:62) , where Q =

Original: [ q 1 , q 2 , . .
Revised: [ q 1 , q 2 , . .

Original: . , q n ] is the orthogonal and Ω = diag ( ω 1 , . .
Revised: . , q n ] is the orthogonal and Ω = diag ( ω 1 , . .

Original: . , ω n ) with all ω i ≥ 0 .
Revised: . , ω n ) with all ω i ≥ 0 .

Original: Recall e = n − 1 / 2 [1 , 1 , . .
Revised: Recall e = n − 1 / 2 [1 , 1 , . .

Original: , 1] (cid:62) ∈
Revised: , 1] (cid:62) ∈

Original: R n × 1 .
Revised: R n × 1 .

Original: Note that
Revised: Note that

Original: [Equation]
Revised: [Equation]

Original: Since matrix ˆ A (cid:62)
Revised: Since matrix ˆ A (cid:62)

Original: [Equation]
Revised: [Equation]

Original: ˆ A is positive semideﬁnite, its all eigenvalues are non-negative.
Revised: A is positive semideﬁnite, its all eigenvalues are non-negative.

Original: Let λ max be the largest eigenvalue of ˆ A (cid:62) ( I − ee (cid:62) )
Revised: Let λ max be the largest eigenvalue of ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A .
Revised: ˆ A .

Original: Consider
Revised: Consider

Original: [Equation]
Revised: [Equation]

Original:  max 
Revised: Let Σ = λ max ( I − ee

Original: [Equation]
Revised: [Equation]

Original: Let Σ = λ max ( I − ee (cid:62) )

Original: − ˆ A (cid:62)( I
Revised: [Equation] A (cid:62)

Original: [Equation]
Revised: [Equation]

Original: A .
Revised: I

Revised: [Equation]

Original: Note that ˆ A
Revised: Note that ˆ A

Original: =
Revised: =

Original: D − 1 A is a stochastic matrix, we have ˆ Ae = e .
Revised: D − 1 A is a stochastic matrix, we have ˆ Ae = e .

Original: Thus, ˆ A (cid:62) ( I − ee (cid:62) )
Revised: Thus, ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A has an eigenvalue 0 and corresponding eigenvecter e .
Revised: ˆ A has an eigenvalue 0 and corresponding eigenvecter e .

Original: Let f i be a normalised eigenvector of ˆ A (cid:62) ( I − ee (cid:62) )
Revised: Let f i be a normalised eigenvector of ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A orthogonal to e , and λ be its corresponding eigenvalue.
Revised: ˆ A orthogonal to e , and λ be its corresponding eigenvalue.

Original: Then we have
Revised: Then we have

Original: [Equation]
Revised: [Equation]

Original: It follows that d M ( ˆ AH ) 2 ≤ λ max d M ( H ) 2 .
Revised: It follows that d M ( ˆ AH ) 2 ≤ λ max d M ( H ) 2 .

Original: Discussion Assume further that ˆ A is doubly stochastic (so that ˆ A (cid:62) e = e ) with positive entries.
Revised: Discussion Assume further that ˆ A is doubly stochastic (so that ˆ A (cid:62) e = e ) with positive entries.

Original: Then by Perron–Frobenius theorem (Gantmakher, 2000), ˆ A (cid:62) ˆ
Revised: Then by Perron–Frobenius theorem (Gantmakher, 2000), ˆ A (cid:62) ˆ

Original: A has a maximum eigenvalue 1 with associated eigenvector e as well.
Revised: A has a maximum eigenvalue 1 with associated eigenvector e as well.

Original: In this case, the matrix ˆ A (cid:62) ( I − ee (cid:62) )
Revised: In this case, the matrix ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A
Revised: ˆ A

Original: =
Revised: =

Original: ˆ A (cid:62)
Revised: ˆ A (cid:62)

Original: ˆ A − ee (cid:62) has a maximum eigenvalue λ max < 1 .
Revised: ˆ A − ee (cid:62) has a maximum eigenvalue λ max < 1 .

Original: Theorem 2.
Revised: Theorem 2.

Original: For a BERT block with h heads, we have
Revised: For a BERT block with h heads, we have

Original: [Equation]
Revised: [Equation]

Original: where v =
Revised: where v =

Original: (1 + s 2 )(1 + √ λhs ) /
Revised: (1 + s 2 )(1 + √ λhs ) /

Original: ( σ 1 σ 2 ) , s > 0 is the largest element of all singular values of all
Revised: ( σ 1 σ 2 ) , s > 0 is the largest element of all singular values of all

Original: W l , λ is the largest eigenvalue of all ˆ A (cid:62) ( I − ee (cid:62) )
Revised: W l , λ is the largest eigenvalue of all ˆ A (cid:62) ( I − ee (cid:62) )

Original: ˆ A for each self-attention matrix ˆ A , and σ 1 , σare the minimum standard deviation for two layer normalization operations.
Revised: ˆ A for each self-attention matrix ˆ A , and σ 1 , σare the minimum standard deviation for two layer normalization operations.

Original: Proof.
Revised: Proof.

Original: From the deﬁnition of self-attention and feed-forward modules, we have
Revised: From the deﬁnition of self-attention and feed-forward modules, we have

Original: [Equation]
Revised: [Equation]

Original: have

Original: [Equation]
Revised: [Equation]

Original: It follows that
Revised: It follows that

Original: [Equation]
Revised: [Equation]

Original: B D ATA S ET B. MNLI
Revised: B D ATA S ET B. MNLI

Original: The Multi-Genre Natural Language Inference (Williams et al., 2018) is a crowdsourced ternary classiﬁcation task.
Revised: The Multi-Genre Natural Language Inference (Williams et al., 2018) is a crowdsourced ternary classiﬁcation task.

Original: Given a premise sentence and a hypothesis sentence, the target is to predict whether the last sentence is an [entailment], [contradiction], or [neutral] relationships with respect to the ﬁrst one.
Revised: Given a premise sentence and a hypothesis sentence, the target is to predict whether the last sentence is an [entailment], [contradiction], or [neutral] relationships with respect to the ﬁrst one.

Original: B. QQP
Revised: B. QQP

Original: The Quora Question Pairs (Chen et al., 2018) is a binary classiﬁcation task.
Revised: The Quora Question Pairs (Chen et al., 2018) is a binary classiﬁcation task.

Original: Given two questions on
Revised: Given two questions on

Original: Quora, the target is to determine whether these two asked questions are semantically equivalent or not.
Revised: Quora, the target is to determine whether these two asked questions are semantically equivalent or not.

Original: B. QNLI
Revised: B. QNLI

Original: The Question Natural Language Inference (Wang et al., 2018b) is a binary classiﬁcation task derived from the Stanford Question Answering Dataset (Rajpurkar et al., 2016).
Revised: The Question Natural Language Inference (Wang et al., 2018b) is a binary classiﬁcation task derived from the Stanford Question Answering Dataset (Rajpurkar et al., 2016).

Original: Given sentence pairs (question, sentence), the target is to predict whether the last sentence contains the correct answer to the question.
Revised: Given sentence pairs (question, sentence), the target is to predict whether the last sentence contains the correct answer to the question.

Original: B. SST- 
Revised: B. SST-

Original: The Stanford Sentiment Treebank (Socher et al., 2013) is a binary sentiment classiﬁcation task for a single sentence.
Revised: The Stanford Sentiment Treebank (Socher et al., 2013) is a binary sentiment classiﬁcation task for a single sentence.

Original: All sentences are extracted from movie reviews with human annotations of their sentiment.
Revised: All sentences are extracted from movie reviews with human annotations of their sentiment.

Original: B. C O LA
Revised: B. C O LA

Original: The Corpus of Linguistic Acceptability (Warstadt et al., 2019) is a binary classiﬁcation task consisting of English acceptability judgments extracted from books and journal articles.
Revised: The Corpus of Linguistic Acceptability (Warstadt et al., 2019) is a binary classiﬁcation task consisting of English acceptability judgments extracted from books and journal articles.

Original: Given a single sentence, the target is to determine whether the sentence is linguistically acceptable or not.
Revised: Given a single sentence, the target is to determine whether the sentence is linguistically acceptable or not.

Original: B. STS-B
Revised: B. STS-B

Original: The Semantic Textual Similarity Benchmark (Cer et al., 2017) is a regression task for predicting the similarity score (from 1 to 5 ) between a given sentence pair, whose sentence pairs are drawn from news headlines and other sources.
Revised: The Semantic Textual Similarity Benchmark (Cer et al., 2017) is a regression task for predicting the similarity score (from 1 to 5 ) between a given sentence pair, whose sentence pairs are drawn from news headlines and other sources.

Original: B. MRPC
Revised: B. MRPC

Original: The Microsoft Research Paraphrase Corpus (Dolan & Brockett, 2005) is a binary classiﬁcation task.
Revised: The Microsoft Research Paraphrase Corpus (Dolan & Brockett, 2005) is a binary classiﬁcation task.

Original: Given a sentence pair extracted from online news sources, the target is to determine whether the sentences in the pair are semantically equivalent.
Revised: Given a sentence pair extracted from online news sources, the target is to determine whether the sentences in the pair are semantically equivalent.

Original: B. RTE
Revised: B. RTE

Original: The Recognizing Textual Entailment (Bentivogli et al., 2009) is a binary entailment classiﬁcation task similar to MNLI, where [neutral] and [contradiction] relationships are classiﬁed into [not entailment].
Revised: The Recognizing Textual Entailment (Bentivogli et al., 2009) is a binary entailment classiﬁcation task similar to MNLI, where [neutral] and [contradiction] relationships are classiﬁed into [not entailment].

Original: B. SWAG
Revised: B. SWAG

Original: The Situations with Adversarial Generations (Zellers et al., 2018) is a multiple-choice task consisting of 113 K questions about grounded situations.
Revised: The Situations with Adversarial Generations (Zellers et al., 2018) is a multiple-choice task consisting of 113 K questions about grounded situations.

Original: Given a source sentence, the task is to select the most possible one among four choices for sentence continuity.
Revised: Given a source sentence, the task is to select the most possible one among four choices for sentence continuity.

Original: B. SQ U AD V 1. 
Revised: B. SQ U AD V 1.

Original: The Stanford Question Answering Dataset (SQuAD v1.1) (Rajpurkar et al., 2016) is a large-scale question and answer task consisting of 100 K question and answer pairs from more than 500 articles.
Revised: The Stanford Question Answering Dataset (SQuAD v1.1) (Rajpurkar et al., 2016) is a large-scale question and answer task consisting of 100 K question and answer pairs from more than 500 articles.

Original: Given a passage and the question from Wikipedia, the goal is to determine the start and the end token of the answer text.
Revised: Given a passage and the question from Wikipedia, the goal is to determine the start and the end token of the answer text.

Original: B. SQ U AD V 2. 
Revised: B. SQ U AD V 2.

Original: The SQuAD v2.0 task (Rajpurkar et al., 2018) is the extension of above SQuAD v1.1, which contains the 100 K questions in SQuAD v1.1 and 50 K unanswerable questions.
Revised: The SQuAD v2.0 task (Rajpurkar et al., 2018) is the extension of above SQuAD v1.1, which contains the 100 K questions in SQuAD v1.1 and 50 K unanswerable questions.

Original: The existence of unanswerable question makes this task more realistic and challenging.
Revised: The existence of unanswerable question makes this task more realistic and challenging.

Original: C I MPLEMENTATION D ETAILS
Revised: C I MPLEMENTATION D ETAILS

Original: The hyper-parameters of various downstream tasks are shown in Table 4.
Revised: The hyper-parameters of various downstream tasks are shown in Table 4.

Original: [Table]
Revised: [Table]

Original: [Table][Table] [Table]
Revised: [Table]

Original: [Table]
Revised: [Table]

Original: , 4e

Original: [Table]
Revised: [Table]

Revised: -5, 1e-5, 1.5e-5, 3e-5, 4e-5, 5e-5]