LGI-GT: Graph Transformers with Local and Global Operators Interleaving

1 Introduction

In recent years, deep learning approaches for graphstructured data have been increasingly popular due to the great successes of graph neural networks (GNNs). While the convolutional neural networks (CNNs) [LeCun et al., 1989] and recurrent neural networks (RNNs) [Elman, 1990] are good at handling grid-like and sequential data respectively, the inherent ability to deal with irregular data (i.e., graphs) and deeply learn their representations make GNNs to be widely applied in many areas, such as data mining and information retrieval. Broadly speaking, most GNNs are instances of a general framework called message passing neural network (MPNN) [Gilmer et al., 2017], and many effective models have been proposed, such as GCN [Kipf and Welling, 2017], GraphSAGE [Hamilton et al., 2017], GIN [Xu et al., 2019], APPNP [Klicpera et al., 2019], and PNA [Corso et al., 2020].

∗Corresponding author

However, the performance of aforementioned GNNs has been inevitably limited by some critical and fundamental problems, including over-smoothing [Li et al., 2018; Chen et al., 2020; Oono and Suzuki, 2020], over-squashing [Alon and Yahav, 2021] and limited expressiveness [Morris et al., 2019]. Concretely, over-smoothing means that with the model becoming sufficiently deep, all node representations will converge to the same and cannot be differentiated any more, while over-squashing refers to that information from a large receptive field is "squashed" into some fixed-length vectors. Due to over-smoothing and over-squashing, GNNs cannot be too deep and meanwhile a node cannot effectively interact with another far away. In addition, message passing GNNs actually encode the rooted subtree around each node, thus their expressive ability is bounded by the 1-WeisfeilerLehman (1-WL) graph isomorphism test [Xu et al., 2019], i.e., expressiveness of GNNs is limited.

Recently, Transformer [Vaswani et al., 2017] has shown its dominance in the field of deep learning and Transformerbased models have performed the best on many computer vision and natural language processing tasks. Considering the great success of Transformer and its potential to address the critical issues of GNNs, graph Transformers (GT) [Dwivedi and Bresson, 2020; Kreuzer et al. ] are proposed and have been attracting more and more attention.

Particularly, there are two main categories of GTs. The first category (Type I) combines Transformer encoder with connectivity information and edge features via specially tailored attention forms or graph-related positional and structural encodings (PE/SE), i.e., the Transformer encoder is still taken as the network backbone, but adapted for graph structures. Examples are [Dwivedi and Bresson, 2020], Graphormer [Ying et al., 2021], SAN [Kreuzer et al., 2021], UniMP (TransformerConv) [Shi et al., 2021] and GRPE [Park et al., 2022]. This class of GTs do not employ the relatively independent GNNmodules. The second one (Type II), however, explicitly utilizes both the message passing GNN modules and Transformer encoder layers, such as GraphTrans [Wu et al., 2021], SAT [Chen et al., 2022] and GPS [Rampasek et al., 2022]. Generally, in Type I methods, the local and global operations are tightly coupled (i.e., node interactions within a neighborhood and over the entire graph are simultaneously considered) , while in Type II models they are loosely coupled. Although model structures of Type I are usually more complex, state-of-the-art (SOTA) results on many benchmarks [Dwivedi et al., 2020; Hu et al., 2020a] are obtained by GTs from Type II.

Specifically, there are several manners to construct GTs in Type II, and among them, GNN+Transformer (i.e., stacking a multi-layer Transformer on a multi-layer GNN, like GraphTrans [Wu et al., 2021]) and parallelization (i.e., feeding a same input into a GNN layer and a global self-attention layer independently in each block then followed by a fusing operation, like GPS [Rampasek et al., 2022]) are two effective schemes. We argue that both of these schemes have shortcomings in model structures, i.e., global and local information cannot be sufficiently utilized. To overcome this problem, we propose a new way to construct GTs with GNN layers and Transformer layers.

In this paper, we introduce a novel architecture of GTs, in which local and global operators interleave (LGI). Local operator refers to a family of message passing GNN modules since they aggregate information from local neighborhoods, while global operator refers to any global attention-based methods like Transformer. Hence, we alternately place few GNN layers and few Transformer layers in sequence and repeat this several times. Via such an LGI scheme, GTs can sufficiently fuse information from neighboring nodes locally and distant nodes globally. For this reason, we call our proposed model LGI-GT, which can to some extent address the critical and fundamental problems of traditional GNNs and perform better than previous GTs. In particular, to propagate global information in LGI-GT, we design a new method to forward propagate embeddings of the [CLS] token [Devlin et al., 2018] in a skip manner. Additionally, we propose a novel message passing method called edge enhanced local attention (EELA), which can be leveraged as a local operator in LGIGT and makes LGI-GT a full-attention GT model (both local and global operators are based on attention mechanisms).

Our main contributions can be summarized as follows:

• We propose LGI-GT, which is a GT model arranging message passing GNN modules and Transformers (as local operators and global operators, respectively) in an interleaving way.
• We propose a novel attention-based message passing module called EELA, which enables LGI-GT to be a full-attention GT.
• We empirically demonstrate that LGI-GT outperforms the state-of-the-art GNNs and GTs, by applying it to multiple graph-level and node-level tasks. In addition, we validate the effectiveness of EELA via an ablation study, and show the superiority of the LGI scheme via a comparison experiment, a depth study and visualization.

2 RelatedWork

In this section, we review the two categories of existing GTs.

Type I GTs. Dwivedi and Bresson [2020] propose an early example using self-attention to construct Transformer for processing graphs with Laplacian eigenvectors as positional encodings. In their model, attention is performed only on the neighbors instead of all the nodes of the graph. Hence, it can be seen as an example of the message passing network and very like to GAT [Velickovic et al., 2018] with different attention implementation details. Likewise, TransformerConv designed in [Shi et al., 2021] also uses local attention only over the 1-hop neighborhood. They adapt the original multi-head attention computing formula for graphs with edge attributes, and combine a gated mechanism to prevent from over-smoothing. Since their model is proposed for semisupervised learning on graphs with nodes partially labeled, they additionally employ a new input for the Transformer by combining node features and node labels. SAN [Kreuzer et al., 2021] firstly uses an auxiliary Transformer mapping eigenvectors and eigenvalues of the graph's Laplacian matrix to a learned positional encoding; then a main Transformer works using full-graph attention. Attention computing formulas of the main Transformer are tailored, by replacing the dot product operation (between key vectors and query vectors) with another one involving edge encoding vectors. Therefore, besides global dependencies, it also considers local connectivity and edge features. Graphormer [Ying et al., 2021] leverages node degree and shortest path to get centrality encoding, spatial encoding and edge encoding, while the attention computation is altered by adding two bias terms to the scaled dot product of query and key before softmax. Moreover, GRPE [Park et al., 2022] adopts relative positional encoding to realize tight integration of node-edge and nodespatial information. By learning the spatial relation embeddings and edge embeddings, spatial bias and edge bias are inserted into the attention score computation formula.

Type II GTs. Rong et al. [2020] design their own message passing GNN and use three such GNNs (with different parameters) to get query, key and value vectors respectively for the consequent self-attention. A great contribution of their work is the pre-training procedure, where they devise two new self-supervised tasks for molecule property prediction. Baek et al. [2021] focus on methods of graph pooling. Their graph multiset Transformer (GMT) takes Transformer as a pooling method and coarsens an original graph layer by layer. Attention of GMT uses two different GNNs for key and value, and by learning query seed vectors whose number is fewer than the number of real nodes, the graph is coarsened once in each layer. Strictly speaking, GMT is not a graph Transformer, but a GNN with a Transformer as its pooling method. To better capture long-range pairwise dependencies, GraphTrans [Wu et al., 2021] is proposed, as a combined model where a multi-layer Transformer is on the top of a multi-layer GNN (an example of the GNN+Transformer scheme as mentioned in Section 1). From the perspective of kernel methods, SAT [Chen et al., 2022] utilizes a shared GNN to get query and key vectors and thus implement a particular kernel function as their own attention score formula; besides, it uses ksubgraph GNNs [Zhang and Li, 2021] (instead of k-subtree ones [Xu et al., 2019]) as more expressive node information extractors beyond the 1-WL test. Furthermore, Rampasek et al. [2022] propose GPS as a GT framework, including kinds of absolute/relative positional/structural encodings into GTs. As for their model architecture, they parallelize GNN and self-attention modules, and then get the sum of their outputs before the feed forward network (FFN) (an example of the parallel scheme as mentioned in Section 1).

In this work, we design a novel GT by interleaving GNN layers and Transformer layers to better leverage the advantages of both. Our proposed LGI-GT belongs to Type II GTs and also keeps loosely-coupled between the message passing and global self-attention.

3 Model Structure Analysis

Since convolution is typically used to extract information of a local patch in an image [LeCun et al., 1989], graph convolution is considered as the similar operation, which is indeed a general scheme representing a class of local message passing methods rather than only GCN [Kipf and Welling, 2017]. A graph local operator refers to an instance of this scheme, usually with a specific message construction function followed by a specific aggregation manner, and we name it GConv for the rest of this paper.

The Transformer encoder layer (hereinafter referred to as TLayer) is used as the global operator, directly modeling dependencies of any two nodes via full-graph attention. Note that many Transformer models can be used as TLayer here, such as Performer [Choromanski et al., 2021] and BigBird [Zaheer et al., 2020].

The main advantage of our proposed LGI-GT over the other two constructing schemes is the interleaving manner where GConvs and TLayers are alternately arranged. Given a graph G, k GConvs and k TLayers, we compare the GNN+Transformer scheme, the parallel scheme and our interleaving scheme in Figure 1. We first show a defect of the GNN+Transformer scheme, as follows.

A graph Transformer in the GNN+Transformer scheme still has the risk of over-smoothing. See Figure 1 (a). Assume that k is just the depth, that makes a GNN

stacked by GConvs incur over-smoothing. Therefore, G1 = GConv(GConv(. . .GConv(G) . . .)) is already an oversmoothed graph, meaning that the features of all nodes in G1 are basically the same. Since a Transformer stacked by k TLayers only depends on node features and handles the graph without considering node connectivity or edge features, G1 as its input is of no meaning for it. As a result, the final output of the whole model G2 = TLayer(TLayer(. . . TLayer(G1) . . .)) is also meaningless, i.e., over-smoothing occurs and thus makes the model unable to perform well.

A graph Transformer in the parallel scheme needs a better fusion method other than simple summation. As for the parallel scheme, see Figure 1 (b), G1 = GConv(G) and G2 = TLayer(G) are computed independently and based on them local and global information are fused immediately, thus the aforementioned over-smoothing scenario may not happen. Nevertheless, it is yet to explore that which fusion method is suitable for the outputs of the parallel GConv and TLayer in each block. As an example, GPS chooses to sum them up, and then feeds the summation into an FFN. However, a simple summation without considering the significant difference of each part may limit the model capacity, so that this operation is too simple and may hurt the model performance.

Advantages of the LGI scheme. As mentioned above, in some cases, the GNN+Transformer models may fail to distinguish different nodes and thus be unable to well accomplish the learning task at hand. On the contrary, in the case where k GConvs and k TLayers are stacked in an interleaving manner (e.g., repeat 1 GConv + 1 TLayer for k times), TLayers can alleviate the over-smoothing problem. Node embeddings as the input of any TLayer are not only meaningful, but also fused with globally important information. Intuitively, while using this architecture, the intermediate node embeddings are informative and beneficial to downstreammodules, as shown in Figure 1 (c). Additionally, since we arrange GConv and TLayer serially versus parallelly, there is no need to consider how to further handle outputs of these two modules, e.g., giving different weights to outputs of them if summation is used.

4 Methodology

We first introduce the architecture of the proposed LGI-GT with a new algorithm to use the [CLS] token. To get a fullattention LGI-GT, we then propose a novel message passing module based on an attention mechanism, called EELA.

4.1 LGI-GT

Local and Global Operators Interleave

The LGI-GT architecture is shown in Figure 2, of which one block is named as an LGI-Block. The LGI-Block takes a graph as its input and outputs an isomorphic one with updated node embeddings. We formalize this procedure as follows:

where A ∈ RN×N and E ∈ R|E|×F denote adjacency matrix and F -dimensional edge features of a graph with N nodes and edge set E, LGI-Block(l) denotes the l-th block of LGIGT (l = 1, 2, ..., L), and Xl ∈ RN×F denotes the intermediate embeddings of nodes and also the output of LGI-Block(l) except that X0 is the node features optionally concatenated with positional or structural encodings. For simplicity, we regard edge features as constants, but note that our method is a flexible and general framework, thus any GConv updating edge embeddings can be easily plugged into it and any PE/SE can be used by concatenating it to node or edge features.

LGI-Block(l) consists of GConvs and TLayers in order, regardless of an optional FFN. Thus Equation (1) can be decomposed into the following equations:

where GConvs(l) and TLayers(l) are just the two components in LGI-Block(l) , as mentioned above, and ˆXl ∈ RN×F is the intermediate node embeddings after GConvs(l) and before TLayers(l) .

Considering GConvs(l) has n layers and TLayers(l) has m as shown in Figure 2 (n and m are both small numbers such as 1 or 2), Equations (2) and (3) can be further decomposed, thus replaced by Equations (4) and (5):

where GConv(l) i is the i-th layer of GConvs(l) (i = 1, 2, ..., n), H(l) i ∈ RN×F is the node intermediate representation within GConvs(l) , H(l) 0 =Xl-1 andH(l) n = ˆXl . Similarly, TLayer(l) j is the j-th layer of TLayers(l) (j = 1, 2, ...,m), ˆH(l) j ∈ RN×F is the node intermediate representation within TLayers(l) , ˆH(l) 0 = ˆXl and ˆH(l) m =Xl . Note that, as shown in Figure 2, there are two batch transformations within each TLayer. Before and after the global self-attention are sparse-to-dense and dense-to-sparse, respectively.

To overcome shortcomings brought by depth, we design some skip connections within LGI-GT, e.g., at the beginning of the first GConv in each LGI-Block, we can set a skip connection to the beginning of the first TLayer.

A New Method to Propagate Embeddings of the [CLS] Token

We specially devise a procedure of propagating embeddings of the [CLS] token in LGI-GT, to guarantee in each block they skip all the local operators and only participate in global operators. Different from that in Graphormer [Ying et al., 2021], GraphTrans [Wu et al., 2021] and SAT [Chen et al., 2022], [CLS] embeddings in our model are propagated in a skip manner. Specifically, the embeddings of [CLS] do not exist in any GConv, so that in forward pass, they keep constant within GConvs and are only updated within TLayers. When there is a learnable vector representing the [CLS] token, Equations (1), (3) and (5) should be modified to Equations (6), (7) and (8) for the special architecture of LGI-GT:

Algorithm 1 Updating the embeddings of [CLS]

Input: CLS0 , sparse batching X0 , E, A Output: CLSL

• 1: for l = 1, 2, ...,L do
• 2: Calculate ˆXl via Equation (2).
• 3: ˆH(l) 0 = ˆXl , C(l) 0 =CLSl-1 .
• 4: for j = 1, 2, ..., m do
• 5: Let ˜H(l) j-1 = [ ˆH(l) j-1 ; C(l) j-1 ].
• 6: Transform ˜H(l) j-1 to the dense batch ¯H(l) j-1 .
• 7: Calculate O1 via Equation (9).
• 8: TransformO1 to the sparse batch ˆO1.
• 9: Calculate O2 via Equation (10).
• 10: [ ˆH(l) j ;C(l) j ] =O2.
• 11: end for
• 12: Xl = ˆH(l) m , CLSl = C(l) m .
• 13: end for
• 14: return CLSL

where CLSl ∈ R1×F is the [CLS] embedding output by LGI-Block(l) (also the same output of TLayers(l) ) except that CLS0 is the original embedding of [CLS], whilst C(l) j ∈ R1×F denotes the intermediate embedding of [CLS] output by TLayer(l) j , C(l) 0 =CLSl-1 and C(l) m =CLSl .

For completeness, we describe the global multi-head attention (MHA) and FFN equations regardless of the specific block or layer, thus ignoring l and j:

where ¯H,O1 ∈ RBNmax×F are both densely batched node representations for B graphs, with Nmax as the maximum node number, ˆO1 ∈ RNsum×F is the sparse batch version of O1 with Nsum as the summation of node numbers, and O2 ∈ RNsum×F is the output of FFN, also the output of the related TLayer. See Figure 2 for more details.

Algorithm 1 describes the procedure to update the embeddings of [CLS] , where the operator [ · ; · ] denotes concatenation along the node dimension.

4.2 Edge Enhanced Local Attention

We propose a new instance of GConv called EELA, using the message passing mechanism as well as local attention mechanism simultaneously. Figure 3 illustrates how a message is constructed in EELA. Edge feature matrix E is first concatenated to source node feature matrix Xs along the feature dimension and then get K and V via linear projection; meanwhile, Q is calculated only using target node feature matrix Xt via another linear layer. The whole procedure in terms of the central node i can be formalized as follows:

where W1 ∈ RF×F is the query weight matrix, W2 ∈ R2F×F is the mutual weight matrix of key and value sharing a same linear module, d is the number of one head dimensions, xj ∈ R1×F and ei,j ∈ R1×F are the embedding vectors of node j and edge (i, j) respectively, x′i ∈ R1×F is the updated embedding vector of node i, N(i) is the 1-hop neighborhood of node i, and [ · ‖ · ] represents concatenation along the feature dimension.

Different from GATConv (attention with too few paramters and without dot product) [Velickovic et al., 2018] and TransformerConv (attention like the original Transformer) [Shi et al., 2021], EELA not only uses linear projection to get Q, K and V , but makes V identical to K and thus reduces the number of parameters while keeping the effectiveness of local attention.

5 Experiments

In this section, we first compared our method to the stateof-the-art baselines including both GNNs and GTs. To demonstrate the superiority of the LGI scheme over the GNN+Transformer scheme and the parallel scheme, we performed another comparison experiment, a depth study and a visualization study on these three GT constructing manners. In addition, we validated the effectiveness of the module EELA via an ablation study.

5.1 Comparison with the SOTAMethods

We conducted a comparison experiment on node-level and graph-level graph representation learning tasks using datasets from different sources for ensuring diversity.

Datasets. Among all the datasets we tested on, ZINC, PATTERN, CLUSTER were from [Dwivedi et al., 2020], whilst ogbg-molpcba and ogbg-code2 were from OGB [Hu et al., 2020a]. Specifically, ZINC is used to do graph regression; PATTERN and CLUSTER target to classify nodes; ogbgmolpcba is for multi-task binary graph classification; ogbgcode2 related task is code summarization where code is represented by the abstract syntax trees processed as graphs, so it is also a graph-level task.

Baselines. There are two classes of baselines - GNNs and GTs. For GNNs, we used GCN [Kipf and Welling, 2017], GIN [Xu et al., 2019], PNA [Corso et al., 2020], DGN [Beaini et al., 2021], GIN-AK+ [Zhao et al., 2022] and CRaW1 [T¨onshoff et al., 2021]; for GTs, we used SAN [Kreuzer et al., 2021], GraphTrans [Wu et al., 2021], SAT [Chen et al., 2022] and GPS [Rampasek et al., 2022]. Among them, GraphTrans represents the GNN+Transformer scheme and GPS is an instance of the parallel scheme. Following [Rampasek et al., 2022], here we did not compare with ensemble methods as well as models pre-trained on extra datasets.

Configurations of LGI-GT. On each dataset, we used the same number of hidden dimensions F and number of layers (or blocks) L as GPS. To exclude performance improvement brought by the advanced GNNs (e.g., PNA) or GNNs more expressive than the 1-WL test (e.g., GraphSNN [Wijesinghe and Wang, 2022] and ID-GNN [You et al., 2021]), we only utilized the basic GINEConv [Xu et al., 2019; Hu et al., 2020b] and GCNConv [Kipf and Welling, 2017] as GConvs, except that EELA was employed for ogbg-molpcba to realize full-attention LGI-GT. As for PE/SE, only Random Walk Structural Encoding (RWSE) was used for ZINC, PATTERN and CLUSTER. To achieve a fair comparison, m = n = 1 were constant (never tuned) across all the datasets. As for the readout methods concerning the graphlevel tasks, we used summation for ZINC, and [CLS] token (see Section 4.1) for ogbg-molpcba and ogbg-code2. Evaluation metrics and dataset splits were the same as in the original papers for each dataset. We took mean ± std of 10 runs with different random seeds as the final result.

Results. As shown in Table 1, all the statistics of the baselines are from [Rampasek et al., 2022] or the original papers (some of GPS are from the github issues). From the results, we can see that the proposed LGI-GT performs consistently better than the SOTA approaches on all the 5 benchmark datasets, and the margins are relatively obvious.

5.2 The Effectiveness of Interleaving GConvs and TLayers

Besides on big datasets, we conducted another comparison experiment on four other smaller ones: NCI1, NCI109 [Wale et al., 2008; Ivanov et al., 2019], ogbg-molbbbp and ogbgmoltox21 [Hu et al., 2020a].

Configurations. On each dataset, we used the same number of GConv, TLayer and hidden dimensions for different schemes. Particularly, we set n = 2,m = 1 for LGI-GT on NCI1, NCI109 and ogbg-moltox21 to try a different combination of n and m, while on ogbg-molbbbp we still set n = 1 as the size is too small. As Section 5.1, on ogbg-molbbbp and ogbg-tox21, we took mean ± std of 10 runs with different random seeds; while on NCI1 and NCI109 we took mean ± std of 20 runs following [Wu et al., 2021].

Results. From Table 2, we can see that both GConv and TLayer are important for LGI-GT, and the LGI scheme is better than the GNN+Transformer and parallel schemes. On 3 out of 4 datasets, LGI-GT surpasses both of them, especially on ogbg-moltox21, while on NCI1 the accuracy of LGI-GT is a little lower than that of Parallel GT.

5.3 Depth Study of GTs

To further validate the effectiveness of interleaving GConvs and TLayers, we performed experiments on PATTERN to observe the performance with respect to (w.r.t.) model depth d, i.e., how the performance changed while models got deeper. Typically, we compared our LGI scheme with the GNN+Transformer scheme and the parallel scheme.

Configurations were the same with LGI-GT in Section 5.1 except for number of layers and constructing schemes (i.e., GNN+Transformer, parallel and LGI). As for the parallel scheme, we followed the model structure of GPS, taking summation of GConv and TLayer outputs before FFN in each block.

Figure 4 shows the influence of the model depth with the GNN+Transformer scheme, parallel scheme and LGI scheme. It is easy to see that with the model becoming deeper, GNN+Transformer and Parallel GT are degraded and the performances tend to become worse overall, while LGIGT keeps steady and the results stay in a high level. The reason why such difference between LGI-GT and the others exists is analyzed in Section 3. Hence, we can conclude that over-smoothing obviously limits GNN+Transformer, a simple summation feature fusion limits the parallel GT, but the LGI scheme is effective and robust to the model depth.

5.4 Model Interpretation

To better view the superiority of our LGI scheme over the other ones from the perspective of model interpretation, on ogbg-molpcba, we visualized the attention weights of the [CLS] node to all the real nodes in the same graph. Figure 5 shows two examples, where the first column displays the original molecules and the other columns from left to right are the visualization results of LGI-GT, GNN+Transformer and Parallel GT in turn. Apparently LGI-GT learns to put more attention on some important atoms like N, O and S, as well as atoms that connect different motifs, while the GNN+Transformer scheme and the parallel scheme fail to do both simultaneously. Hence, we can conclude that LGI-GT is good at handling structure information and focuses on the discriminative nodes.

5.5 The Effectiveness of EELA

We tested our EELA module on ogbg-molpcba by comparing with two other attention-based message passing modulesTransformerConv [Shi et al., 2021] and GATConv [Velickovic et al., 2018].

Most configurations were the same with LGI-GT in Section 5.1 except for the GConv types and model structures. Particularly, following GPS [Rampasek et al., 2022], we took an FFN after a simple summation to fuse outputs of GConvs and TLayers for the Parallel GT, and global average pooling was taken as its readout method. As shown in Table 3, apparently GTs with EELA outperform the counterparts with TransformerConv and GATConv in all three schemes, demonstrating that EELA is more suitable to construct full-attention GTs than other local attention-based message passing modules.

6 Conclusion

In this paper, we classify current graph Transformers into two types and analyze the advantages of our interleaving scheme over other GT constructing methods in terms of model structures of Type II GTs. More importantly, we propose LGI-GT, a graph Transformer interleaving message passing layers and Transformer encoder layers. Adapting to the LGI structure, we introduce a new algorithm to forward propagate embeddings of the [CLS] token in a skip manner. Additionally, we design a new graph local operator called EELA, which is used to construct full-attention GTs (including our LGI-GT) better than existing attention-based message passing modules. Empirically, we demonstrate that our LGI-GT outperforms other SOTA GNNs and GTs on both node-level and graphlevel tasks, and through several ablation studies, we further validate the effectiveness of the LGI scheme and EELA.

Acknowledgments

This work was partially supported by the National Key Research and Development Program of China under Grant No. 2018AAA0100400, HY Project under Grant No. LZY2022033004, the Natural Science Foundation of Shandong Province under Grants No. ZR2020MF131 and No. ZR2021ZD19, Project of the Marine Science and Technology cooperative Innovation Center under Grant No. 22-05CXZX-04-03-17, the Science and Technology Program of Qingdao under Grant No. 21-1-4-ny-19-nsh, and Project of Associative Training of Ocean University of China under Grant No. 202265007.