Nested named entity recognition (NER) has been receiving increasing attention. Recently, Fu et al. (2020) adapt a span-based constituency parser to tackle nested NER. They treat nested entities as partially-observed constituency trees and propose the masked inside algorithm for partial marginalization. However, their method cannot leverage entity heads, which have been shown useful in entity mention detection and entity typing. In this work, we resort to more expressive structures, lexicalized constituency trees in which constituents are annotated by headwords, to model nested entities. We leverage the Eisner-Satta algorithm to perform partial marginalization and inference efficiently. In addition, we propose to use (1) a two-stage strategy (2) a head regularization loss and (3) a head-aware labeling loss in order to enhance the performance. We make a thorough ablation study to investigate the functionality of each component. Experimentally, our method achieves the state-of-the-art performance on ACE2004, ACE2005 and NNE, and competitive performance on GENIA, and meanwhile has a fast inference speed. Our code will be publicly available at: github.com/LouChao98/nner_as_parsing. Named Entity Recognition (NER) is a fundamental task in information extraction, playing an essential role in many downstream tasks. Nested NER brings more flexibility than flat NER by allowing nested structures, thereby enabling more fine-grained meaning representations and broader applications (Byrne, 2007; Dai, 2018). Traditional sequence-labeling-based models have achieved remarkable performance on flat NER but fail to handle nested entities. To resolve this problem, there are many layer-based methods (Ju et al., 2018; Fisher and Vlachos, 2019; Shibuya and Hovy,  Corresponding Author 2020; Wang et al., 2020, 2021) proposed to recognize entities layer-by-layer in bottom-up or top-down manners. However, they suffer from the error propagation issue due to the cascade decoding. Recently, Fu et al. (2020) adapt a span-based constituency parser to tackle nested NER, treating annotated entity spans as a partially-observed constituency tree and marginalizing latent spans out for training. Their parsing-based method, namely PO-TreeCRF, admits global exact inference thanks to the CYK algorithm (Cocke, 1969; Younger, 1967; Kasami, 1965), thereby eliminating the error propagation problem. However, their method does not consider entity heads, which provide important clues for entity mention detection (Lin et al., 2019; Zhang et al., 2020d) and entity typing (Katiyar and Cardie, 2018; Choi et al., 2018; Chen et al., 2021). For example, University and California are strong clues of the existence of ORGEDU and STATE entities in Fig.1. Motivated by this and inspired by head-driven phrase structures, Lin et al. (2019) propose the Anchor-Region Network (ARN), which identifies all entity heads firstly and then predicts the boundary and type of entities governed by each entity head. However, their method is heuristic and greedy, suffering from the error propagation problem as well. Our main goal in this work is to obtain the best of two worlds: proposing a probabilistically principled method that enables exact global inference like Fu et al. (2020), meanwhile taking entity heads into accounts like Lin et al. (2019). To enable exact global inference, we also view observed entities as partially-observed trees. Since constituency trees cannot model entity heads, we resort to lexicalized trees, in which constituents are annotated with headwords. A lexicalized tree embeds a constituency tree and a dependency tree (Gaifman, 1965), and lexicalized constituency parsing can thus be viewed as joint dependency and constituency parsing (Eisner and Satta, 6183 [Bickford] [Bickford] [Bickford] Reginold Bickford , [researcher] [researcher] a researcher [university] at [university] [university] [university] the university [California] of California [Diego] at [Diego] San Diego PER NAME STATE CITY PER ORGEDU Figure 1: An example sentence with a compatible latent lexicalized constituency tree (top) and observed entities (down). 1999; Collins, 2003). Fig.1 illustrates an example lexicalized tree. Joint dependency and constituency parsing has been shown to outperform standalone constituency parsing (Zhou and Zhao, 2019; Fernndez-Gonzlez and Gmez-Rodrguez, 2020) possibly because modeling dependencies between headwords helps predict constituents correctly. Hence, in the context of nested NER, we have reasons to believe that modeling latent lexicalized constituency trees would bring improvement in predicting entities over modeling latent constituency trees, and we verify this in experiments. When using a lexicalized constituency tree for nested NER, only part of unlexicalized spans, i.e., entities, are observed, so we need to marginalize latent spans and dependency arcs out for training. Inspired by the masked inside algorithm of Fu et al. (2020), we propose a masked version of the Eisner-Satta algorithm (Eisner and Satta, 1999), a fast lexicalized constituency parsing algorithm, to perform partial marginalization. We also adopt the Eisner-Satta algorithm for fast inference. Besides the difference in parsing formalism and algorithms, our work also differs from the work of Fu et al. (2020) and Lin et al. (2019) in the following three aspects. First, inspired by Zhang et al. (2020a), we adopt a two-stage parsing strategy, i.e., we first predict an unlabeled tree and then label the predicted constituents, instead of using the one-stage parsing strategy of PO-TreeCRF. We show that two-stage parsing can improve the performance of both PO-TreeCRF and our proposed method. Second, Lin et al. (2019) observe that each entity head governs only one entity span in most cases, so they impose a hard constraint of that during learning and inference, which is potentially harmful since the constraint is not always satisfied. Instead, we add a soft KL penalty term to encourage satisfaction of the constraint, which is reminiscent of posterior regularization (Ganchev et al., 2010; Zhang et al., 2017). Third, considering that gold entity heads are not given, Lin et al. (2019) propose a bag loss for entity boundary detection and labeling. However, this loss is heuristic and brings an additional hyperparameter, to which the final performance is sensitive. In contrast, entity boundary detection is learned in the first stage of our method, and in the second stage, we propose a more principled labeling loss based on expectations (i.e., marginal likelihoods) of all possible entity heads within gold entity spans, which can be estimated efficiently and does not introduce new hyperparameters. We conduct experiments on four benchmark datasets, showing that our model achieves state-of-the-art results on ACE2004, ACE2005 and NNE, and competitive results on GENIA, validating the effectiveness of our method. A labeled constituency tree can be represented as a rank-3 binary tensor T where T ijk = 1 if there is a span from the i -th word to the j -th word with label k in the tree and T ijk = 0 otherwise. We assume the 0 -th label is preserved for  (i.e., no label) without loss of generality. Similarly, an unlabeled constituency tree can be represented as a binary matrix T (cid:48) . One-stage span-based constituency parsers 6184 decompose the score of a labeled constituency tree into the scores of constituents s ijk : s ( T ) = (cid:88) ijk T ijk s ijk They use the CYK algorithm to recover the optimal labeled tree. In contrast, two-stage constituency parsers score unlabeled trees and constituent labels independently. They decompose the score of an unlabeled constituency tree into the scores of spans s i,j : s ( T (cid:48) ) = (cid:88) ij T (cid:48) ij s ij They use the CYK algorithm to recover the optimal unlabeled tree in the first stage and then use a separate component to label spans, including the  label, in the second stage. Zhang et al. (2020c) show that adopting the two-stage parsing strategy leads to a better result in constituency parsing. PO-TreeCRF (Fu et al., 2020) adapts a one-stage constituency parser to tackle nested NER. It views the set of entities y := { ( i, j, k ) , . . . } as observed parts of a constituency tree T where ( i, j ) is the unlabeled entity span and k is the entity label. We refer to other constituents as latent spans. A labeled tree T is compatible with y if T ijk = 1 for any entity ( i, j, k )  y and T ij 0 = 1 for all latent spans ( i, j ) (recall that the 0 -th label is  ). Define set  T ( y ) as all compatible trees with y . PO-TreeCRF maximizes the total likelihood of all compatible trees: s ( y ) = log (cid:88) T   T ( y ) exp( s ( T )) log p ( y ) = s ( y )  log Z where log Z is the log-partition function. The diffi-culty is how to estimate s ( y ) efficiently. Fu et al. (2020) propose the masked inside algorithm to tackle this, in which they set all incompatible span (overlapped but not nested with any of y ) values to negative infinity before running the inside algorithm. We refer readers to their paper for more details. Figure 1 shows an example lexicalized constituency tree. We omit all constituent labels for brevity. Each constituent is annotated by a headword. A non-leaf constituent span consists of two adjacent sub-constituents and copies the headword from one of them. We refer to the copied headword as the inherited head and the other headword as the noninherited head. We can draw a dependency arc from the inherited head to the non-inherited head. A dependency tree can be obtained by reading off all headwords recursively, and hence in this view, a lexicalized constituency tree embeds a dependency tree and a constituency tree. The O ( n 4 ) Eisner-Satta algorithm (Eisner and Satta, 1999) can be used to calculate the partition function or obtain the best parse if we decompose the score of a lexicalized constituency tree into scores of spans and arcs. We refer interested readers to Appendix A for details of the Eisner-Satta algorithm. Notations Given a lengthn sentence x = x 0 , ..., x n  1 with (gold) entity set y := { ( i, j,  ) , . . . } , where ( i, j ) is an unlabeled entity span and  is the set of entity labels (there could be multiple labels for one entity). We denote  y as the set of unlabeled entity spans, i.e.,  y := { ( i, j ) , . . . } . The first stage always predicts 2 n  1 spans 1 and most of them are not entities. Hence naively adopting the two-stage parsing strategy to nested NER suffers from the imbalanced classification problem when predicting labels in the second stage because the  label would dominate all the entity labels. To bypass this problem, we modify unlabeled constituency trees by assigning 0-1 labels to unlabeled constituency trees, where 0 stands for latent spans and 1 stands for entities. It transfers the burden of identifying non-entities to the first stage, in which the binary classification problem is much more balanced and easier to tackle. The total training loss can be decomposed into: L = L tree + L label + L reg where L tree is a 0-1 labeled constituency tree loss, L label is a head-aware labeling loss and L reg is a regularization loss based on the KL divergence. Encoding and scoring We feed the sentence into the BERT encoder (Devlin et al., 2019), apply scalar mixing (Peters et al., 2018) to the last four layers of BERT, and apply mean-pooling to all sub-word embeddings to obtain word-level contextual embedding. We concatenate static word embedding, e.g., GloVe (Pennington et al., 2014), to the contextual embedding to obtain the word representation a = a 0 , .., a n  1 . Then we feed a into a three-layer bidirectional LSTM (Hochreiter and Schmidhuber, 1997) network (BiLSTM): . . . , (  b i ,  b i ) ,    = BiLSTM ([ . . . , a i , . . . ]) Next, we use deep biaffine scoring functions (Dozat and Manning, 2017) to calculate span scores s c  R n  n  2 and arc scores s d  R n  n : e c,in/outi = MLP c,in/out ([  b i ;  b i +1 ]) e d,in/outi = MLP d,in/out ([  b i ;  b i ]) s cij = PN ([ e c,ini ; 1 ] TW c [ e c,outj ; 1 ]) s dij = PN ([ e d,ini ; 1 ] TW d [ e d,outj ; 1 ]) , where MLPs are multi-layer perceptrons that project embeddings into k -dimensional spaces; W c  R ( k +1)  2  ( k +1) , W d  R ( k +1)  ( k +1) are trainable parameters; PN is Potential Normalization, which normalizes scores to follow unit Gaussian distributions and has been shown beneficial (Fu et al., 2020). Scores of trees A 0-1 labeled lexicalized constituency tree l embeds an unlabeled dependency tree d and a 0-1 labeled constituency tree c . The label set is { 0 , 1 } , where 0 denotes latent spans and 1 denotes entity spans. We use a binary rank-3 tensor C  R n  n  2 to represent c , where C ijk = 1 if and only if there is a span from x i to x j with label k in c ; and a binary matrix D  R n  n to represent d , where D ij = 1 if and only if there is an arc from x i to x j in d . We define the score of l as : s ( l ) = s ( c ) + s ( d ) = (cid:88) ijk C ijk s cijk + (cid:88) ij D ij s dij Structural tree loss We marginalize all latent spans and arcs out to define the loss: s (  y ) = log (cid:88)  T   T exp( s (  T )) L tree = log Z  s (  y ) where  T is the set of all compatible lexicalized trees whose constituents contain  y ; log Z is the log-partition function that can be estimated by the Eisner-Satta algorithm. For each compatible tree  T   T , the 0-1 labels are assigned in accordance with the entity spans in  y . We use a masked version of the Eisner-Satta algorithm (Appendix A) to estimate s (  y ) . Regularization loss As previously discussed, entity heads govern only one entity in most cases. But imposing a hard constraint is sub-optimal because there are also cases violating this constraint. Hence we want to encourage the model to satisfy this constraint in a soft manner. Inspired by posterior regularization (Ganchev et al., 2010; Zhang et al., 2017), we build a constrained TreeCRF and minimize the KL divergence between constrained and original unconstrained TreeCRFs. The first problem is how to construct the constrained TreeCRF. We propose to hack the forward pass (i.e., inside) of the Eisner-Satta algorithm to achieve this: we decrease the arc scores by a constant value (we typically set to 0.4) whenever the parent has already governed an entity during computing the inside values, so it discourages a head having several children and thus governing several spans. We refer readers to Appendix A for more details. The second problem is how to optimize the KL divergence efficiently for exponential numbers of trees. We adopt the specific semiring designed to calculate KL divergences between structured log-linear models (Li and Eisner, 2009) from the Torch-Struct library (Rush, 2020) 2 . The calculation of KL divergence is fully differentiable and thus is amenable to gradient-based optimization methods. It has the same time complexity as the forward pass of the Eisner-Satta algorithm. We denote the value of KL divergence as L reg . To incorporate entity head information when labeling entity spans, we score the assignment of label l  L to a span ( i, j ) with head x k as follows: e l,in/outi = MLP l,in/out ([  b i ;  b i +1 ]) e l,headi = MLP l,head ([  b i ;  b i ]) s labelijkl = TriAff ( e l,ini , e l,outj , e l,headk ) , where Triaff is the triaffine scoring function (Zhang et al., 2020b); L is the set of all labels. We reuse the encoder (BiLSTM) from Stage I. Nested named entities could have multiple labels. For instance, 7% entity spans in the NNE dataset (Ringland et al., 2019) have multiple labels. We use a multilabel loss introduced by Su (2020). For each ( i, j,  )  y , consider a potential head x k with i  k  j , we define the loss as: l ( i, j, k,  ) = log(1 + (cid:88) l L /  exp( s labelijkl )) + log(1 + (cid:88) l   exp(  s labelijkl )) Since the gold entity heads are not given, we define the head-aware labeling loss based on expectation over the headword for each entity span: L label = (cid:88) ( i,j,  )  y (cid:88) i  k  j  ijk l ( i, j, k,  ) where  ijk is the marginal likelihood of x k being the headword of span ( i, j ) under the TreeCRF, which satisfies (cid:80) i  k  j  ijk = 1 and can be estimated efficiently via the backward pass (i.e., back-propagation (Eisner, 2016)) of the Eisner-Satta algorithm. We conduct experiments on four datasets: ACE2004 (Doddington et al., 2004), ACE2005 (Walker, Christopher et al., 2006), GENIA (Kim et al., 2003) and NNE (Ringland et al., 2019). For ACE2004, ACE2005 and GENIA, we use the same data splitting and preprocessing as in Shibuya and Hovy (2020) 3 . For NNE, we use the official preprocessing script 4 to split train/dev/test sets. We refer readers to Appendeix B.1 for implementation details and to Appendix B.2 for data statistics of each dataset. We report span-level labeled precision (P), labeled recall (R) and labeled F1 scores (F1). We select models according to the performance on development sets. All results are averaged over three runs with different random seeds. We show the comparison of various methods on ACE2004, ACE2005 and GENIA in Table 1. We note that there is an inconsistency in the data prepossessing. For instance, the data statistics shown in Table 1 of (Shibuya and Hovy, 2020) and Table 5 of (Shen et al., 2021) do not match. More seriously, we find Shen et al. (2021); Tan et al. (2021) use context sentences, which plays a crucial role in their performance improvement but is not standard practice in other work. In addition, they report the best result instead of the mean result. Hence we rerun the open-sourced codes of Shen et al. (2021); Tan et al. (2021) using our preprocessed data and no context sentences and we report their mean results over three different runs. We also rerun the code of PO-TreeCRF for a fair comparison. We can see that our method outperforms PO-TreeCRF, our main baseline, by 0.30/2.42/0.64 F1 scores on the three datasets, respectively. Our method has 87.90 and 86.91 F1 scores on ACE2004 and ACE2005, achieving the state-of-the-art performances. On GENIA, our method achieves competitive performance. We also evaluate our method on the NNE dataset, whereby there are many multilabeled entities. Table 2 shows the result: our method outperforms Pyramid by 0.27 F1 score. Structured vs. unstructured We study the effect of structural training and structured decoding as a whole. Unstructured is a baseline that adopts the local span classification loss and local greedy decoding. 1-stage is our re-implementation of PO-TreeCRF, which adopts the latent structural constituency tree loss and uses the CYK algorithm for decoding. 1-stage+ LEX  adopts the latent structural lexicalized constituency tree loss and uses the Eisner-Satta algorithm for decoding. All methods use the same neural encoders. We can see that 1-stage outperforms the unstructured baseline by 0.33 F1 score. Further, 1-stage+ LEX  outperforms 1-stage by 0.25 F1 score, verifying the effectiveness of using latent lexicalized constituency tree structures. 1-stage vs. 2-stage On the unstructured model, we adopt a 0-1 local span classification loss in the first stage of the two-stage version, and we observe that the two-stage version performs similarly the one-stage version. On the other hand, we observe improvements on structured methods: 2-stage outperforms 1-stage by 0.23 F1 score and 2stage+ LEX  outperforms 1-stage+ LEX  by 0.18 F1 scores, validating the benefit of adopting the two-stage strategy. Moreover, "2-stage(0/1)+ LEX " outperforms "2-stage+ LEX " by 0.15 F1 score, suggesting the effectiveness of bypassing the imbalanced classification problem. de-5 They did not report Pyramid-Full with BERT only. However, with BERT+ALBERT, Pyramid-Full only outperforms Pyramid-Basic with a small margin ( < 0 . 1 ). 6 The max and logsumexp versions are the best models for BERT only and BERT+Flair respectively. coding in a decoupled way here. -parsing denotes the case that we use the latent lexicalized constituency tree loss for training, while we do not use the Eisner-Satta algorithm for parsing and instead predict spans locally whenever their label score of 1 is greater than that of 0. We can see that it causes a performance drop of 0.49 F1 score, indicating the importance of structural decoding, i.e., parsing. It is also worth noting that -parsing outperforms the unstructured baseline by 0.42 F1 score, showing the benefit of structural training even without structural decoding. Effect of head regularization We can see that using the regularization loss brings an improvement of 0.24 F1 score (86.32->86.56). In the case study (Section 5.2), we observe that some common errors are avoided because of this regularization. Effect of head-aware labeling loss We can see that using the head-aware labeling loss brings an improvement of 0.30 F1 score (86.32 -> 86.62). When combined with the head regularization, we achieve further improvements because of more accurate head estimation (Appendix B.3). Table 4 shows example predictions of our models. In the first pair, 2-stage predict reasonable structures (visualized in B.5), but fail to label entities, whereas 2-stage (0-1) predicts further correct labels. The second pair shows that, by constraining head sharing and head-aware entity labeling, +both successfully detect bus as a headword, then produce correct entity boundaries and labels. Besides, +both can be seen to handle both fine-grained and coarse-grained entities in the last two predictions: this bus near the airport is predicted into two entities but all sites and people in Iraq remains one multilabeled entity. Table 5 gives the most common headwords of each type predicted by our model on ACE2005. We find that the most frequently predicted headwords are gold headwords 7 , except for some common function words, e.g., in and of . It proves the ability of our model in recognizing headwords. One concern regarding our method is that since the Eisner-Satta algorithm has a O ( n 4 ) time complexity, it would be too slow to use for NER practitioners. Fortunately, the Eisner-Satta algorithm is amenable to highly-parallelized implementation so that O ( n 3 ) out of O ( n 4 ) can be computed in parallel (Zhang et al., 2020b; Rush, 2020), which greatly accelerates parsing. We adapt the fast implemen-7 ACE2005 is additionally annotated with headwords. We only use them for evaluation. tation of Yang and Tu (2022b) 8 . Empirically, we observe linear running time on GPUs in most cases. We show the comparison of (both training and decoding) running time in Table 6. We measure the time on a machine with Intel Xeon Gold 6278C CPU and NVIDIA V100 GPU. We can see that compared with PO-TreeCRF, which also uses a highly-parallelized implementation of the O ( n 3 ) CYK algorithm, our method is around 20% slower in training and decoding, which is acceptable. Notably, both PO-TreeCRF and our method are much faster than Seq2Set (Tan et al., 2021) and Locate&Label(Shen et al., 2021). Nested NER Nested NER has been receiving increasing attentions and there are many methods proposed to tackle it. We roughly categorize the methods into the following groups: (1) Span-based methods: Luan et al. (2019); Yu et al. (2020); Li et al. (2021) directly assign scores to each potential entity span. (2) Layered methods: Ju et al. (2018); Fisher and Vlachos (2019) dynamically merge sub-spans to larger spans and Shibuya and Hovy (2020); Wang et al. (2021) use linear-chain CRFs and recursively find second-best paths for predicting nested entities. (3) Hypergraph-based methods: Lu and Roth (2015); Katiyar and Cardie (2018) propose different hypergraph structures to model nested entities but suffer from the spurious structure issue, and Wang and Lu (2018) solve this issue later. (4) Object-detection-based methods: Shen et al. (2021) adapt classical two-stage object detectors to tackle nested NER and Tan et al. (2021) borrow the idea from DETR (Carion et al., 2020). (5) Parsing-based methods (Finkel and Manning, 2009; Wang et al., 2018; Fu et al., 2020; Yang and Tu, 2022a). (6) Sequence-to-sequence methods (Yan et al., 2021). Our method belongs to parsing-based methods. Finkel and Manning (2009) use a non-neural TreeCRF parser. Wang et al. (2018) adapt a shift-reduce transition-based parser. Fu et al. (2020) use a span-based neural TreeCRF parser. Recently, Yang and Tu (2022a) propose a bottom-up constituency parser with pointer networks to tackle nested NER as well. All of them cast nested NER to constituency parsing, while we cast nested NER to lexicalized constituency parsing and our method 8 https://github.com/sustcsonglin/ span-based-dependency-parsing/blob/main/src/inside/eisner_satta.py 6189 Model Prediction 2-stage [I] PER have never heard of [a pig like [this] WEA ] WEA before ! 2-stage (0-1)  [I] PER have never heard of a pig like this before ! 2-stage (0-1) [Police] PER surrounded [this bus near [the airport] FAC ] VEH,FAC with [guns] WEA drawn . + both  [Police] PER surrounded [this bus] VEH near [the airport] FAC with [guns] WEA drawn . + both  [Blix] PER stressed that [council] ORG resolutions call for [[U.N.] ORG inspectors] PER to have access to [all sites and people in [Iraq] GPE ] FAC,PER . Structured models using partial trees Full gold parse trees are expensive to obtain, so there are many methods proposed to marginalize over latent parts of partial trees, performing either approximate marginalization via loopy belief propagation or other approximate algorithms (Narad-owsky et al., 2012; Durrett and Klein, 2014) or exact marginalization via dynamic programming algorithms (Li et al., 2016; Zhang et al., 2020b; Fu et al., 2020; Zhang et al., 2021). Naradowsky et al. (2012); Durrett and Klein (2014) construct fac-tor graph representations of syntactically-coupled NLP tasks whose structures can be viewed as latent dependency or constituency trees, such as NER, semantic role labeling (SRL), and relation extraction. Li et al. (2016); Zhang et al. (2020b) perform partial marginalization to train (second-order) TreeCRF parsers for partially-annotated dependency parsing. Zhang et al. (2021) view arcs in SRL as partially-observed dependency trees; Fu et al. (2020) view entities in nested NER as partially-observed constituency trees; and we view entities in nested NER as partially-observed lexicalized constituency trees in this work. Lexicalized parsing Probabilistic context-free grammars (PCFGs) have been widely used in syntactic parsing. Lexicalized PCFGs (L-PCFGs) leverage headword information to disambiguate parsing and are thus more expressive. Eisner and Satta (1999) propose an efficient O ( n 4 ) algorithm for lexicalized parsing. Collins (2003) conduct a thorough study of lexicalized parsing. Recently, neurally parameterized L-PCFGs have been used in unsupervised joint dependency and constituency parsing (Zhu et al., 2020; Yang et al., 2021). Our work removes the grammar components and adapts the dynamic programming algorithm of lexicalized parsing (Eisner and Satta, 1999) in the spirit of span-based constituency parsing (Stern et al., 2017). We have presented a parsing-based method for nested NER, viewing entities as partially-observed lexicalized constituency trees, motivated by the close relationship between entity heads and entity recognition. Benefiting from structural modeling, our model does not suffer from error propagation and heuristic head choosing and is easy for regularizing predictions. Furthermore, our highly-parallelized implementation enables fast training and inference on GPUs. Experiments on four benchmark datasets validate the effectiveness and efficiency of our proposed method. We thank the anonymous reviewers for their constructive comments. This work was supported by the National Natural Science Foundation of China (61976139).
abstain abstain abstain abstain abstain method objective objective result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain other abstain abstain abstain result result abstain method abstain abstain objective abstain method abstain abstain objective result abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain other abstain abstain method method abstain method abstain abstain method method abstain abstain abstain abstain method abstain abstain abstain method abstain abstain abstain abstain method method method method method method method method abstain result abstain abstain result abstain result abstain result result result abstain result method abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain method abstain abstain method abstain abstain abstain method abstain abstain other abstain other other other other other abstain other other other other other other other other other other abstain abstain abstain abstain abstain abstain abstain abstain method objective method abstain objective other other