A Semi-Autoregressive Graph Generative Model for Dependency Graph Parsing
Year: 2023

Abstract:
Recent years have witnessed the impressive progress in Neural Dependency Parsing. According to the different factorization approaches to the graph joint probabilities, existing parsers can be roughly divided into autoregressive and non-autoregressive patterns. The former means that the graph should be factorized into multiple sequentially dependent components, then it can be built up component by component. And the latter assumes these components to be independent so that they can be outputted in a one-shot manner. However, when treating the directed edge as an explicit dependency relationship, we discover that there is a mixture of independent and interdependent components in the dependency graph, signifying that both aforementioned models fail to precisely capture the explicit dependencies among nodes and edges. Based on this property, we design a Semi-Autoregressive Dependency Parser to generate dependency graphs via adding node groups and edge groups autoregressively while pouring out all group elements in parallel. The model gains a trade-off between non-autoregression and autoregression, which respectively suffer from the lack of target inter-dependencies and the uncertainty of graph generation orders. The experiments show the proposed parser outperforms strong baselines on Enhanced Universal Dependencies of multiple languages, especially achieving 4% average promotion at graph-level accuracy. Also, the performances of model variations show the importance of specific parts.

heading: 1 Introduction
text: Dependency graph in neural parsing is a directed graph representing semantic dependencies between words, with a transitive relation traveling from the rooted node to all words in the sentence phase by phase. As such, transition-based parsing seems to be a natural choice, as it builds up the parsing graph sequentially so that the dependency relationships
can be captured. However, graph-based parsing dominates recent competitions on parsing technologies including IWPT 2020 and 2021 (Bouma et al., 2020, 2021), even if using a simple biaffine attention (Dozat and Manning, 2017) only to predict the whole graph at once. To explore a more effective parsing method that can represent these dependency relationships in a rigorous manner, we define and construct Topological Hierarchies for dependency graphs based on the explicit dependencies carried by them. According to the characteristics of topological hierarchies, we proposes a Semi-Autoregressive Dependency Graph Parser (SAGER) – a novel graph-based parsing fashion via the semi-autoregressive graph generation.
Generally, autoregressive graph generation indicates that the model dynamically adds nodes and edges based on the generated sub-graph structure until reaching the complete graph. It brings a challenge to determine the generation order of graphic data, because there is no conventional reading order like text data (Chen et al., 2021). Although the dependency graphs stipulate the strict sequential dependencies by directed edges, there is a lack of such topological orders between sibling nodes. For instance, node b in Figure 1.a depends on the node a because there is an explicit edge pointing from a to b. However, it is hard to decide the dependency relationship between node d and node e as they are not linked neither directly nor indirectly. Previous works on directed graph generation solve the problem surfacely. Cai and Lam (2019, 2020) sort these sibling nodes randomly at the early stage of training and then change them to a deterministic order (e.g., relation-frequency) at later training steps. Some other works do the sorting by referring to the orders of the known sequences like word order or alphanumerical order (Zhang et al., 2019a,b; Bevilacqua et al., 2021). Such imposed orders would bring more exposure bias (Ranzato et al., 2016) to teacher forcing training. More specifically, these sibling
4218
nodes are essentially orderless and non-interlogical. They cannot form stationary and logical patterns like words in sentences. As a result, it is hard for the sibling nodes to be generated in the same order as in the training, causing learned knowledge invalid and later predictions misled. The aforementioned random ordering seems to alleviate the problem to some extent, but it destabilizes and complicates the training process and generally results in inferior models.
Instead of imposing orders on these sibling nodes, we assume them (including their incoming edges) to be conditionally independent to construct topological hierarchies as the generation orders. As shown in Figure 1.b, we divide nodes into several hierarchies according to their furthest distances from the root node. We can see that there are no explicit dependency relationships between nodes in the same hierarchy. Besides, nodes in the later hierarchies only depends on those in the previous hierarchies, forming a natural generation sequence. For a directed acyclic graph (DAG), it at least has one topological ordering but only has one topological hierarchy. At each generation step, we firstly predict all new nodes in parallel and then calculate their incoming edges by the biaffine attention (Dozat and Manning, 2017). In a word,
our model autoregressively adds node groups and edge groups but non-autoregressively generates elements in these groups. See Figure 1.c for our semi-autoregressive generation process.
Another challenge lies at the probable edge sparsity problem when representing sub-graph structures. Sparse graph representation models like GCN (Kipf and Welling, 2017) heavily rely on the given adjacency to capture context information. That means it may fail to represent historical information completely and efficiently when predicted edges make mistakes. An extreme situation of edge sparsity is that the new nodes have no incoming edges predicted so that the model can only represent its node features rather than the sub-graph structure. To enhance the robustness of the generator, we adopt the dense structure of Transformer (Vaswani et al., 2017). In our Graph Transformer, there are implicit edges linking from the nodes in the previous and current hierarchies to the new node. Then, the predicted explicit edges serve as the bias to adjust the attention distribution over the implicit edges so that the model can adaptively select useful structural information.
Overall, this paper proposes a novel direction – semi-autoregression to deal with dependency parsing problems, distinguished with autoregression and non-autoregression (detailed definitions about them are available in § 2). With the dependencies denoted as the directed edges, the semiautoregressive pattern unfolds graphs in the order of topological hierarchies, which strictly follows the explicit dependency relationships defined in dependency graphs. Our model strikes a reasonable balance, resulting in it neither ignoring inter-output dependencies like non-autoregressive models, nor suffering from severe exposure bias in generation orders like autoregressive models On the experimental side, we evaluate SAGER on Enhanced Universal Dependencies (EUD) which are non-tree dependency graphs. In addition to the official evaluation metric Enhanced Label Attachment Scores (ELAS), we design a graph-level matching score (GMS) to assess the probability of returning an completely correct graph. Our model outperforms other baselines in both metrics especially GMS, showing that it is good at overcoming some intractable prediction errors. Finally, we introduce multiple model variations to investigate the effect of different model components and show that our model is well-designed, especially the parts of dis-
carding imposed orders and adding implicit edges.

heading: 2 Related Work
text: Autoregressive Parser. Generally, a generator is in an autoregressive fashion provided its generation probability at each step is conditional on items it produces previously. Transition-based parser obviously conforms to the characteristic, as it updates the action probability every step based on the words, tags and label embeddings previously put in the buffer and stack (Chen and Manning, 2014). Meanwhile, we note that some mechanisms commonly used in autoregressive generators are used to improve transition-based parsers like beam search and pointer networks (Weiss et al., 2015; Ma et al., 2018; Fernández-González and Gómez-Rodríguez, 2019). On the other hand, Cheng et al. (2016) proposes a graph-based autoregressive parser by adding arcs sequentially with the considerations of previous parsing decisions. However, it should not be taken as a rigorous graph generative model as it does not generate by extending the sub-graph structures. Actually, instead of dependency graphs, it is more prevalent that leverage the autoregressive graph generators to parse Abstract Meaning Representation (AMR) (Cai and Lam, 2019, 2020; Zhang et al., 2019b,a). They are all in the (fully) autoregressive pattern that an order is imposed to nodes and edges without topological orderings. In this paper, we focus on investigating the effects of these imposed orderings by introducing some variations of the proposed model.
Non-Autoregressive Parser. In contrast, nonautoregression implies that all components factorized from the graph are independent, so their probabilities do not affect each other and can be obtained in parallel at any time. A representative non-autoregressive parser is Deep Biaffine Attention (BiAtt) (Dozat and Manning, 2017) which assuming all edges are independent. For the treestructure dependency graphs, it is often followed by a searching algorithm for the Maximum Spanning Tree (MST). Some heuristic algorithms (Li et al., 2020; Kiperwasser and Goldberg, 2016) construct the MST step by step, which yet does not mean they are in the autoregressive manner because all edge probabilities are predicted at once and fixed before the searching. As to the higher-order graph-based parsers, Ji et al. (2019) incorporates the secondorder knowledge into the word representations and still uses the BiAtt as the final parser. Wang et al.
(2019); Zhang et al. (2020) decompose the graph into components of different second-order parts. Different from BiAtt that each component is an edge, here some components consists of two edges whose joint probabilities can be calculated as a whole by a trilinear function. They still belong to non-autoregressive parsers because their components are independent of each other and disable to be subdivided.

heading: 3 Proposed Model

heading: 3.1 Definitions
text: Problem Definition. Conditional on the source sentence S = (wn)Nn=1, the task is to generate a dependency graph hierarchy by hierarchy. The generation process can be denoted as a sequence of components: (C(t))Tt=0, T ≤ N . We firstly turn dependency graphs to DAGs by deleting the back edges in their cycles. It should be mentioned that there are only a few graphs with cycles and we can add these removed edges back by rules before evaluations. Then we can construct topological hierarchies based on the furthest distance from each node to the root node. The initial component C(0) = {v0} in the 0-th hierarchy only has a root node. When t > 0, the component in the t-th hierarchy is defined as C(t) = {V (t), E(t)}. Let Vt = ⋃t j=0 V
(j), then V (t) = {vi}|Vt|−1i=|Vt−1| is a set of nodes in the t-th hierarchy. And, E(t) = {(vj , vi, zji)|vj ∈ Vt−1, vi ∈ V (t)} is a set of edges pointing from nodes in the previous hierarchies to the current nodes, where vj is the head of vi and zji is the label on the arc.
Explicit and Implicit Edge. We define two kinds of edges, namely explicit edges and implicit edges. The former is what we need to really predict. Let Ni be the explicit first-order neighbours of the node vi ∈ V (t) and Di be the implicit neighbours, and Ni∪Di = Vt. Notably, nodes in Ni can not appear in V (t) according to the definition of topological hierarchy. They have uni-directional edges pointing to the node vi with arc labels, and these edge can be found in E(t). On the other hand, nodes in Di should not have pointed to vi, but our model does so because we expect nodes to learn structural information adaptively. It should be mentioned that nodes in the same component or hierarchy also have implicit edges linking to each other, i.e., V (t) ⊆ Di.
Head and Dependent Representation. We define two representations of the same node with different roles, namely the head representation and the dependent representation. Each generated node will first be used as a dependent node to calculate its incoming arcs, and then as a head node until the end of generation. We define the head vector of a node vi ∈ V (t) as hi and its dependent vector as di. For a component, its head matrix H(t) = Fθ(Vt, Et, S) and dependent matrix D(t) = Fθ(Vt, Et−1, S) are the concatenations of multiple corresponding node representation, where Et = ⋃t j=0E
(t). We can see that the difference between them is that the latter inputs lack E(t), which means there are no available explicit edges pointing to V (t) nodes when calculating dependent representations. We shall mention that the graph representation model Fθ(·) can represent all components, but we only need to focus on the new component at each generation step because the new component does not affect node representations in the previous components.
Training Objective. The objective is to maximize the graph joint probability J :
J = T∏
t=1
P (V (t)|Vt−1, Et−1)P (E(t)|Vt, Et−1)
P (V (t)|Vt−1, Et−1) = ∏
vi∈V (t) P (vi|Vt−1, Et−1)
P (E(t)|Vt, Et−1) = ∏
ei∈E(t) P (ei|Vt, Et−1)
Vt = Vt−1 ∪ V (t), Et = Et−1 ∪ E(t)
It indicates that we autoregressively generate the new node group V (t) and the edge group E(t) based on groups generated previously and the elements in the same group are independent.

heading: 3.2 Graph Generation Process
text: Figure 2 presents the generative process from the 3-rd step to the 4-th step. Specifically, At the generation step t, we firstly update head representations H(t−1) for the last-step nodes V (t−1) using their network structure information E(t−1). Notably, although there only generates an intermediate sub-graph of the entire structure, the explicit topological information of V (t−1) nodes is completed because they would not have incoming arcs from nodes generated later. On the other hand, these
sentence words have been represented as a dense matrix S by a Transformer-encoder. Then, their probabilities of being selected are calculated by:
P (w1:N ) = MaxPool [ σ ( H(t−1)W1W⊤2 S ⊤ )]
V (t) = {wn|P (wn) > 0.5}
where W ∈ Rd×d is a linear transformation matrix. This operation is similar to a multi-label classification. Every source word is assigned with an independent probability, and words with probabilities larger than 0.5 are selected as new nodes V (t). To represent these new nodes as D(t) when their network structural information are unknown, we suppose that there are implicit edges pointing from previous nodes to these nodes. Besides, these new nodes are connected to each other by implicit edges. Although it is impossible to appear explicit edges among them, this operation can further enrich node representations. Their connections are illustrated by the second adjacency matrix in the middle block of Figure 2. Explicit edge connections and types are then figured out by Deep Biaffine Attention (Dozat and Manning, 2017):
E(t) = DeepBiaffine ( ∥t−1j=0H(j),D(t) )
where ∥t−1j=0H(j) is achieved by concatenating head representations of all nodes in the previous hierarchies. The generation proceeds via repeating the aforementioned operations until no words can be selected as new nodes.

heading: 3.3 Graph Representation Model
text: Recently, Transformer (Vaswani et al., 2017) has made impressive progress in the graph representation field (Ying et al., 2021). In essence, Transformer regards inputs as an undirected fullyconnected graph, thus serving as a special graph representation model that can enjoys global perception at all layers. Previous works focusing on adapting Transformer-encoder to node or graph classification, while this paper modifies Transformerdecoder to conduct graph generation.
Let x(l)i denote the node vi embedding at the l-th layer. If the node vi is in the component Ct and copied from the source word wn, its initial node embedding x(0)i should be the summation of:
x (0) i = S[n] +P[t]
where S,P indicate word embeddings and hierarchical positional encodings respectively, as shown
in Figure 2. Nodes in the same hierarchy have the same hierarchical positional encodings.
The message passing layer actually takes the position of the masked self-attention layer in the decoder. The original decoder self-attention helps every word to aggregate left-ward contexts. In contrast, every node in our model not only aggregates left-ward contexts (i.e, nodes in previous hierarchies), but also nodes in the same hierarchy. To distinguish explicit edges and implicit edges, the message vector mji of the node vj with an explicit edge pointing to the node vi should be enriched with prior structural knowledge by
m (l) ji =
{ x (l) j + relu ( x (l) j Uzji ) , vj ∈ Ni
x (l) j , vj ∈ Di
where Uzji ∈ Rd×d indicates the parametric embedding matrix of the edge label zji. These edge embedding metrics are shared across all layers. Notably, we assume that the central node vi is selfconnected implicitly, i.e. vi ∈ Di. The reduction function is then defined as the multi-head attention:
αji = exp
( xiWQW ⊤ Km ⊤ ji )
∑ vu∈Ni∪Di exp ( xiWQW⊤Km ⊤ ui )
x (l)′
i =   H∥ h=1   ∑ vj∈Ni∪Di αhjim (l) ji W h V    WO
We can see that the query is the node embedding xi, and the keys and values are those message vectors mji. Its output x (l)′
i is then fed into the feedforward layer to enter the next layer:
x (l+1) i = FFN
( x (l)′
i
)
The outputs x(L) of the final layer are head representations or dependent representations.
The edge embedding matrices U give the model access to prior structural knowledge and enable it to select useful prior knowledge adaptively. When all structural knowledge is useless (i.e, parameters in U are trained to be zeros) and each hierarchy only contains one node, the graph model degrades to a vanilla Transformer decoder.

heading: 4 Experiment
text: Datasets. We tune our models primarily on 15 languages that appear in IWPT 2020 dataset and IWPT
2021 dataset (Bouma et al., 2020, 2021). The two shared tasks focus on EUD (Schuster and Manning, 2016) which are non-tree graphs with reentrancies, empty nodes and sparsity cycles. To construct the topological hierarchy, we need to delete the back edges in cycles firstly and add them back by rules at inference time. For the language that has multiple treebanks, we simply concatenate all of its treebanks. Besides, we use gold tokenization and gold sentence segmentation during training and development. At test time, we use the results of tokenization and segmentation provided by the top ranked models.
Baseline Models. Our comparison experiments aim to investigate the performances of models themselves, without considering some learning techniques like ensembling (Grünewald et al., 2021), two-stage training (Shi and Lee, 2021) and automated concatenation of embeddings (Wang et al., 2021). We conclude four strong baselines from top-ranked systems in IWPT 2021 and IWPT 2020, namely Deep Biaffine Attention (Dozat and Manning, 2017), Tree-Graph Parser (Shi and Lee, 2021), Second-order Parser (Wang et al., 2019, 2020) and Language-specific UDify (Kondratyuk and Straka, 2019; Kanerva et al., 2020). Their results are reported after eliminating the effects of learning techniques.
Evaluation Metrics. ELAS results are evaluated by the official script provided by IWPT 2021. Besides, we also define a graph-level matching score (GMS) to investigate whether the model can deal with a few arcs that are difficult to be predicted properly in a sample. Since we segment UD sentences from raw texts, the numbers of sentences are
different for each system. Therefore, GMS is an F1 score around the number of absolutely matched graphs,
Recall = #matched graph
#gold sentences
Precision = #matched graph
#system sentences
GMS = 2×Recall × Precision Recall + Precision
where # represents The number of .
Word Embeddings. Similar to the operations in most top-ranked systems, our word embeddings S[n] are initialized as the weighted summation of the corresponding hidden states in XLM-R layers (Conneau et al., 2020), where the weights are the learned attention distribution over all XLM-R layers. For the word composed of multiple subwords, we extract the hidden states of the last one. We set up the dimension in the graph representation model as d = 1024, the same as that in the pre-trained models.
Other Details. We train models directly on each language with Teacher Forcing Training to output all head (dependent) representations at once. Besides, we truncate the input sentences to 100 words at training time. We totally run 100 epochs with 16 batch size and select the model parameters base on the ELAS on the development sets. We train our models on a single v100 with a speed of about 10000 samples in 10 minutes. We use ReZero (Bachlechner et al., 2021) in our graph transformer, instead of LayerNorm operations commonly used in Transformer. In this case, we do not
need to use the warm-up learning schedule, and we use Adam optimizer with the 0.97 decay ratio of the learning rate. We set up the initial learning rate of pre-trained embeddings as 2e − 5, and that of others as 1e− 3. Besides, dropout rates in the part of pre-training and graph representation are set to 0.1, while the output layers of nodes and edges are set to 0.3. We build up the vocabulary on the arc labels for each language respectively. To shrink the size of edge vocabularies, we follow the delexicalization operations of arc labels (Grünewald and Friedrich, 2020) and re-lexicalize them before evaluations.

heading: 5 Results and Analysis

heading: 5.1 Main Results
text: The official evaluation metrics ELAS of our models and baselines are shown in Table 1. We note that SAGER achieves at least comparable results on all languages. In IWPT 2021, in addition to obtaining the best average ELAS performance (average ∼ 0.4% points), our model brings significant improvements over multiple languages like Lithuanian (∼ 1.6% points), French (∼ 0.9% points), English (∼ 0.6% points). This enhancement is more significant when comparing our model with the top two models in IWPT 2020 (average ∼ 1.6% points ). Besides, sharper increases appears in GMS of IWPT 2021 (average ∼ 3.6% points) and IWPT 2020 (average ∼ 6.9% points), where our model achieves an amazing rising against the baselines in all languages.
It should be mentioned that a higher ELAS does not mean a higher GMS, as shown in the results of Czech (cs) language. In other words, some obstinate errors are fixed to make more dependency graphs completely correct, but there appear some samples where more mistakes concentrate. This situation derives from the inherent characteristics of autoregressive generation that the prediction accuracy at one certain step is heavily dependent on that at historical steps. In ideal states, the historical information can calibrate some obstinate errors by the learned dependencies. However, once deviation occurs in an intermediate step, it may lead to mistakes that should not have been made. This is the essential reason that autoregressive parsers are weaker than non-autoregressive parsers. By comparison, our semi-autoregressive parser mitigates the negative impact of this characteristic by removing some unreasonable dependency relationships,
thus resulting in better performances in both ELAS and GMS.

heading: 5.2 Model Variant Ablation Studies
text: To investigate the importance of different model components and input features, we evaluated the following variations of our model.
A. Autoregressive generation with random orders. We impose random orders to the sibling nodes, so the model is converted to a fullyautoregressive generator. At each step, the model only generates a new node and its all incoming edges. The sibling nodes will be re-ordered after a training epoch.
B. Autoregressive generation with word orders. The sibling nodes are sorted by the positions of the node words in the sentence.
C. Combine random orders and word orders. The sibling nodes are firstly randomly sorted at the early stage of training and fixed to the word orders at later training.
D. No implicit edges. Without the implicit edges, the graph representation model is similar to GAT (Velickovic et al., 2018) but the messages are additionally enriched with the arc label information.
E. No implicit edges in the same hierarchy. We remove the implicit edges between nodes in the same topological hierarchy. In this case, each node only has the incoming arcs from the nodes in the previous hierarchies.
F. No explicit edges. We replace all explicit edges by implicit edges, which is equal to forcing the edge embedding matrix U to zeros.
G. No hierarchical positional encodings. In this case, the model would lose the sequential relationships between hierarchies and fail to locate nodes of different hierarchy.
The ablation results of 6 languages are summarized in Figure 3. We firstly focus on the fullyautoregressive variations, namely the model A, B and C. We can see that there are significant declines in performances when imposing orderings to sibling nodes, indicating that the autoregressive mode heavily suffers from exposure bias in terms of generation orderings. Besides, the extent of declines varies a lot in different languages, ranging from over 30% in the Slovak (sk) dataset and within 1% in the English (en) and Italian (it) datasets. This proves that the impact of imposed sorting is quite unstable.
Moving to the model D, E and F which are variations with respect to explicit and implicit edges. Although it is not as significant as the negative effects of using autoregressive modes, that of removing implicit or explicit edges cannot be ignored. Generally, implicit edges play a more important role than explicit edges as the performances of model D are often lower than those of model E and F. This validates that the edge sparsity is the major problem of graph generation after the uncertainty of generation orderings. Besides, the implicit edges in the same hierarchy (see model E) and the historical arc label information (see model F) are both compulsory model components because the model always performs worse when dropping them. The final is the model without hierarchical positional encodings. Compared with other variations, its performance is the closest to the origin model, implying that our graph representation model is not very sensitive to the sequential relationships between hierarchies.

heading: 5.3 Error analysis of Topological Hierarchy
text: Since a topological hierarchy regulates the rough topological structure of a dependency graph, its prediction accuracy is crucial for the whole model.
We investigate the node accuracy on 5 languages (see Figure 4.a), and find that about 90% nodes can fall into correct hierarchies. Even the language performing worst under the ELAS evaluation can reach 80% node accuracy. We then provide the model with the oracle node group at each generation step and plot the comparison results against the origin model in Figure 4.b. There is about a 1% increase of ELAS on most languages when using oracle TH. It is surprising that oracle TH does not bring about improvement to the English dataset, indicating that corrupt topological hierarchies do not always lead to incorrect arcs. Actually, it would cause bad results only when the dependent node of an arc is generated before its head nodes. It does not matter for corruptions that do not shuffle the orders of heads and dependents.

heading: 5.4 Sensitive analysis of Layers
text: We test the sensitivity of ELAS results to different L. As shown in Figure 5, We select four languages whose ELAS are significantly higher than baselines’ when L = 2. We find that our model still outperforms the baseline whichever L is used. Besides, it is hard to disclose a trend between model performance and the number of lay-
ers from the four plots. This is possibly because graph transformer can capture context information of high-order neighbours even with one layer. Overall, SAGER is insensitive to the number of layers.

heading: 6 Case Study
text: To better understand the drawbacks of nonautoregressive and autoregressive models, we present two examples in Figure 6. In the first example, semi-auto performs better because it can predict the arc nsubj:xsubj with the help of the previously predicted arc xcomp. The two edges are heavily dependent. In contrast, non-auto fails because it assumes independency between edges. In the graph produced by the auto, the edge between the first measure and the comma should have been predicted after linking measure to weight, but the model actually skips the step and predicts a wrong arc conj. This is probably because (nsubj, obj, conj) is a very highly-frequent dependent relationship in autoregressive graph sequences.

heading: 7 Conclusion and Limitation
text: This paper explores a semi-autoregressive dependency graph parser (SAGER) that learns the explicit dependencies in dependency graphs. This generation pattern captures the edge dependencies
while reducing exposure bias, resulting in a more effective parser and two insights about graph generation, namely the ordering uncertainty and edge sparsity. We believe that the proposed algorithm can be applied in other language parsing problems such as OIA (Open Information Annotation) (Sun et al., 2020; Wang et al., 2022) and graph generation problems (Sun and Li, 2019).
The limitations of our work are inference speed and decoding strategy. The efficiency of semiautoregressive inference is lower than that of nonautoregressive algorithms, so currently it cannot be applied to scenarios with high frequency requests. Furthermore, this paper only introduces greedy search as a decoding strategy. Overcoming the challenge of introducing many complex decoding strategies such as beam/tree search (Liu et al., 2020; Ma et al., 2021) belongs to our future work.

heading: A For every submission:
text: 3 A1. Did you describe the limitations of your work?
sec 7
A2. Did you discuss any potential risks of your work? Not applicable. Left blank.
3 A3. Do the abstract and introduction summarize the paper’s main claims? the abstract and sec 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 7 Did you use or create scientific artifacts? Left blank.
B1. Did you cite the creators of artifacts you used? No response.
B2. Did you discuss the license or terms for use and / or distribution of any artifacts? No response.
B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? No response.
B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? No response.
B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? No response.
B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. No response.
C 3 Did you run computational experiments? Left blank.
3 C1. Did you report the number of parameters in the models used, the total computational budget (e.g., GPU hours), and computing infrastructure used? appendix 2
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.
3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found hyperparameter values? appendix 2
3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? table 1
3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? sec 4 and appendix 2
D 7 Did you use human annotators (e.g., crowdworkers) or research with human participants? Left blank.
D1. Did you report the full text of instructions given to participants, including e.g., screenshots, disclaimers of any risks to participants or annotators, etc.? No response.
D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students) and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? No response.
D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to crowdworkers explain how the data would be used? No response.
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? No response.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? No response.

heading: Future Work
text: , 2021) belongs to our future work