A Sequence-to-Sequence&Set Model for Text-to-Table Generation
Year: 2023

Abstract:
Recently, the text-to-table generation task has attracted increasing attention due to its wide applications. In this aspect, the dominant model (Wu et al., 2022) formalizes this task as a sequence-to-sequence generation task and serializes each table into a token sequence during training by concatenating all rows in a topdown order. However, it suffers from two serious defects: 1) the predefined order introduces a wrong bias during training, which highly penalizes shifts in the order between rows; 2) the error propagation problem becomes serious when the model outputs a long token sequence. In this paper, we first conduct a preliminary study to demonstrate the generation of most rows is order-insensitive. Furthermore, we propose a novel sequence-to-sequence&set text-to-table generation model. Specifically, in addition to a text encoder encoding the input text, our model is equipped with a table header generator to first output a table header, i.e., the first row of the table, in the manner of sequence generation. Then we use a table body generator with learnable row embeddings and column embeddings to generate a set of table body rows in parallel. Particularly, to deal with the issue that there is no correspondence between each generated table body row and target during training, we propose a target assignment strategy based on the bipartite matching between the first cells of generated table body rows and targets. Experiment results show that our model significantly surpasses the baselines, achieving state-of-the-art performance on commonlyused datasets.1

heading: 1 Introduction
text: Text-to-table generation is a task that aims to generate a tabular description of important information
1We release the code at https://github.com/ DeepLearnXMU/seq2seqset
*Equal contribution. †Corresponding author.
for a given text. As shown in Figure 1, the input text is a post-game summary of a basketball game, and the output is a table containing statistics about players. Usually, this task can be widely used to extract important structured information, such as restaurant reviews (Novikova et al., 2017), team and player statistics (Wiseman et al., 2017), Wikipedia infoboxes (Bao et al., 2018) and biographies (Lebret et al., 2016), benefiting humans understand the input text more intuitively.
In this aspect, Wu et al. (2022) first propose sequence-to-sequence (seq2seq) text-to-table generation models. They first serialize each table to a
5358
token sequence by concatenating all rows in a topdown order. Back to Figure 1, they represent each table row as a cell sequence, and then represent the entire table by concatenating all rows. Then, they train seq2seq models fine-tuned from BART (Lewis et al., 2020). During inference, the model generates a table in a token-by-token manner and the generated sequence is eventually split by ⟨s⟩ and ⟨n⟩ to obtain the structured table.
Despite some success, the above-mentioned sequence generation manner leads to two defects in the model. First, imposing the above-mentioned predefined order on generating rows in the dataset may bring wrong bias to the model training (Ye et al., 2021; Lu et al., 2022a). Here, we still take Figure 1 as an example. Each row represents the statistics of a basketball player, and there is no obvious dependency between the statistics of different players. Thus, when considering the order of generating rows, the inconsistent order between generated rows and targets will cause a large training loss, even if the generated rows and targets are exactly the same. Second, as the number of generated rows increases, the outputted token sequence becomes longer, which makes the seq2seq models encounter the serious error propagation problem (Ye et al., 2021; Tan et al., 2021). Besides, the seq2seq model generates a table autoregressively, of which time complexity is the number of rows times the number of columns, resulting in inefficient GPU acceleration.
In this paper, we first conduct a preliminary study to inspect the effect of row generation order on seq2seq models. Specifically, we randomly reorder table body rows to construct different training datasets. Then, we use these datasets to train seq2seq models, of which performance is compared on the same dataset. Experimental results show that these models exhibit similar performance, proving that the generation of most table body rows is order-insensitive.
Moreover, we propose a novel sequence-tosequence&set (Seq2Seq&set) text-to-table generation model which decomposes the table generation into two steps: generating a table header, i.e., the first row of the table, and then a set of table body rows. As shown in Figure 2, our model mainly consists of three modules: 1) Text Encoder. It is a vanilla Transformer encoder, encoding the input document into hidden states; 2) Table Header Generator that produces the table header as a token
sequence; 3) Table Body Generator generating different table body rows in parallel, where each row is generated token by token. To generate different rows from the same text, we equip the generators with a set of learnable Row Embeddings. Besides, we add a set of learnable Column Embeddings to enhance the semantic consistency between cells in the same column.
During the model training, we need to determine the correspondence between the generated table body rows and targets, so as to achieve the orderindependent generation of table body rows. To this end, we propose to use the model to generate the first cells of table body rows. Then, we efficiently determine target assignments according to the matching results between these first cells and those of targets, which can be modeled as a bipartite matching problem and solved by the Hungarian algorithm (Kuhn, 1955). Afterwards, we calculate the training loss based on the one-to-one alignments between the generated table body rows and targets. Besides, during the model inference, we force table body generator to output the same number of cells with the previously-generated generated table header.
Compared with the seq2seq models (Wu et al., 2022), our model has the following advantages: 1) our model is able to not only alleviate the order bias caused by the sequence generation but also reduce the effect of error propagation on the generation of long sequences; 2) our model achieves faster generation speed since table body rows can be efficiently generated in parallel.
Experiment results show that our model significantly improves the quality of the generated table, achieving state-of-the-art performance on commonly-used datasets.

heading: 2 Related Work
text: Information Extraction (IE) refers to the automatic extraction of structured information such as entities, relationships between entities, and attributes describing entities from unstructured sources (Sarawagi et al., 2008). The common IE tasks include named entity recognition (NER), relation extraction (RE), event extraction (EE), etc.
To achieve high-quality IE, researchers have proposed various task-specific IE methods. With the development of deep learning, researchers mainly focus on neural network based generation models, which are often seq2seq pre-trained models gener-
ating serialized structured information. Compared with traditional IE methods, these methods have achieved comparable or even superior results in RE (Zeng et al., 2018; Nayak and Ng, 2020), NER (Chen and Moschitti, 2018; Yan et al., 2021), EE (Li et al., 2021; Lu et al., 2021). Along this line, researchers resort to unified models (Paolini et al., 2021; Lu et al., 2022b) that model multiple IE tasks as the generation of sequences in a uniform format.
In this work, we mainly focus on text-to-table generation that aims to generate structured tables from natural language descriptions. Note that textto-table generation can be considered as the dual task of table-to-text generation, which intends to generate a textual description conditioned on the input structured data. Usually, these structured data are represented as tables (Wiseman et al., 2017; Thomson et al., 2020; Chen et al., 2020) or sets of table cells (Bao et al., 2018; Parikh et al., 2020). Compared with traditional IE tasks, this task does not rely on predefined schemas. In this regard, Wu et al. (2022) first explore this task as a seq2seq generation task by fine-tuning a BART model (Lewis et al., 2020) for generation. By contrast, we model the generation of each table as a table header and then a set of table body rows. To this end, we propose a Seq2Seq&set text-to-table model, which can alleviate the defects caused by the sequence generation in the conventional seq2seq models.

heading: 3 Preliminary Study
text: We first conduct a preliminary study to inspect the effect of row generation order on the Seq2Seq model (Wu et al., 2022). Since the table header is the first row of a table containing column names which should be generated first, so we only randomly reorder table body rows to construct different training datasets. Then, we individually train the Seq2Seq models using these datasets with the same setting as the original model, and compare their performance on the same dataset (Wiseman et al., 2017).
From Table 1, we can observe that the original model and their variants exhibit similar performance. Besides, we calculate the sample standard deviation of model performance and find that all standard deviations are no more than 0.1. These results strongly demonstrate that the generation or-
2Notice that in (Wu et al., 2022), they use row header F1, column header F1 and non-header cells F1. Here, we individually rename these to the first column F1, table header F1 and data cell F1, so as to avoid ambiguity in descriptions.
ders of table body rows have a negligible effect on the model performance. In other words, the generation of table body rows is order-insensitive.

heading: 4 Our Model
text: In this section, we describe our model in detail. As shown in Figure 2, our model is composed of three modules: Text Encoder, Table Header Generator and Table Body Generator. Then, we give a detailed description of the model training.

heading: 4.1 Text Encoder
text: Our text encoder is used to encode input documents. It is identical to the BART (Lewis et al., 2020) encoder, consisting of Le Transformer encoder layers. The input document is first tokenized into X=x1, x2, ..., x|X| using a byte-level Byte-Pair Encoding (Wang et al., 2020) tokenizer.
Then, text encoder iteratively updates the hidden states in the following way:
A(l)e = MultiHead(H (l) e ,H (l) e ,H (l) e ), (1) H(l+1)e = FFN(A (l) e ), (2)
where H(l)e ∈R|X|×d is the hidden states at the l-th layer, and d is the dimension of embeddings and hidden states. MultiHead(·) is a multi-head attention function and FFN(·) refers to a feed-forward network. We initialize H(0)e as the sum of Word(X) and Pos(X), where Word(·) is a word embedding
function and Pos(·) is a learnable position embedding function. Note that we omit the descriptions of layer normalization and residual connection in each sublayer. Please refer to (Vaswani et al., 2017; Lewis et al., 2020) for more details.
The above process iterates Le times. Finally, we obtain the hidden states H(Le)e of the input document, which will provide useful information for both table header generator and table body generator via attention mechanisms.

heading: 4.2 Table Header Generator
text: As mentioned previously, our model is designed to generate a table as a table header and a set of table body rows. To this end, we follow previous studies (Zhang et al., 2018; Su et al., 2019) to decomposes the table generation into two steps. We first propose table header generator, which is the same as the BART decoder and generates the table header Y0=y01, y 0 2, ..., y 0 |Y0| as a token sequence.
Given the encoder hidden states H(Le)e , our generator produces the table header in an autoregressive manner:
A (l) d0 = MultiHead(H (l) d0 ,H (l) d0 ,H (l) d0), (3) A (l) d0 = MultiHead(A (l) d0 ,H (Le) e ,H (Le) e ), (4)
H (l+1) d0 = FFN(A (l) d0), (5)
where H(l)d0 ∈ R|Y 0|×d is the hidden states at the l-th layer. In the first layer, we initialize the j-th decoder input as the sum of Word(y0j−1), Pos(y 0 j−1),
Row(y0j−1) and Col(y 0 j−1), where Word(·) and Pos(·) share parameters with text encoder, row embeddings Row(·) and column embeddings Col(·) will be described in the next subsection.
Finally, after iterating the above process for Ld times, we obtain the last-layer hidden states H
(Ld) d0 = {H (Ld) d0,j }1≤j≤|Y0|, where H (Ld) d0,j is used to
output the j-th target token:
y0j = argmax(WoH (Ld) d0,j ), (6)
where Wo ∈ R|V|×d is a learnable parameter matrix, and V is the target vocabulary.

heading: 4.3 Table Body Generator
text: To generate a set of table body rows in parallel, we propose a novel semi-autoregression table body generator. It is also stacked with Ld layers, each of which consists of self-attention, cross-attention and feed-forward network sublayers. Particularly, it shares parameters with table header generator, so that it can directly exploit the hidden states of table header generator via selfattention. This generator produces M table body rows {Ym}1≤m≤M in parallel, under the semantic guidence of H(Le)e and {H(l)d0}1≤l≤Ld . Particularly, we use a special ⟨∅⟩ token to represent “no corresponding row”. Formally, the m-th table body row, Ym = ym1 , y m 2 , ..., y m |Ym| is generated in an
auto-regressive way:
H (l) dm = [H (l) d0 ;H (l) dm], (7) A (l) dm = MultiHead(H (l) dm,H (l) dm,H (l) dm), (8) A (l) dm = MultiHead(A (l) dm,H (Le) e ,H (Le) e ), (9)
H (l+1) dm = FFN(A (l) dm), (10)
where H(l)dm ∈ R|Y m|×d is the hidden states for generating Ym. Note that our generator exploits both hidden states of table header and previous tokens in the same row to produce a table body row.
Taking the sum of word embeddings and positional embeddings as inputs, the vanilla Transformer decoder can only generate a sequence but not a set. To generate a set of table body rows in parallel, we introduce M additional learnable embeddings called Row Embeddings (See the green squares in Figure 2) into inputs, guiding table body generator to produce different rows. Here, M is a predefined parameter that is usually larger than the maximum number of rows in training data. Furthermore, to enhance the semantic consistency between cells in the same column, we add another learnable embeddings named Column Embeddings (See the blue squares in Figure 2) into inputs. Column embeddings are similar to positional embeddings but are defined at the cell level. By doing so, tokens of cells in the same column are equipped with identical column embeddings.
Formally, with row and column embeddings, the initial hidden state of our generator becomes
H (0) dm,k = Word(y m k−1) + Pos(y m k−1)
+ Row(ymk−1) + Col(y m k−1),
(11)
where ymk−1 is the (k−1)-th output token at the mth table body row, and Row(·) and Col(·) are row and column embedding functions, respectively.
Through Ld times of hidden state updates, we obtain the last-layer hidden states {H(Ld)dm }1≤m≤M . Finally, based on H(Ld)dm,k, we obtain the token with maximum probability as the output:
ymk = argmax(WoH (Ld) dm,k). (12)
In order to maintain an equal number of cells in every row, table body generator keeps generating a row until the number of ⟨s⟩ matches that in the header.

heading: 4.4 Training
text: Training Loss As mentioned above, we decompose the generation of a table into two steps. Correspondingly, we define the training loss as:
L = λLh + (1− λ)Lb, (13)
where λ is a hyper-parameter to balance the effect of the table header generation loss Lh and the table body generation loss Lb.
As for Lh, we follow common practice to define Lh as a cross-entropy loss between the predictive distributions of the generated table header and the target one:
Lh = − |Y0|∑
j=1
logp̂0j (y 0 j ), (14)
where p̂0j (·) is the predictive probability of the j-th token in the table header Y0 using teacher forcing.
Target Assignments Based on the First Cells We also define Lb as a cross-entropy loss between the predictive distributions of the generated table body rows and targets. However, there is no correspondence between each generated table body row and target during training, and hence we can not directly calculate Lb. To deal with this issue, we learn from the recent studies on set generation (Carion et al., 2020; Ye et al., 2021; Xie et al., 2022) and propose to efficiently determine target row assignments according to the matching results between the first cells of generated table body rows and those of targets. Here, we use the first cell to represent the whole row, because it is usually unique and often contains the important information of a table such as a name and a primary key.
Concretely, we first use our model to generate the first cells of all table body rows. During this process, we obtain generation probability distributions {Pm}1≤m≤M , where Pm = {pmk }1≤k≤|Pm| and pmk is the predictive distribution at the k-th timestep for the m-th table body row. Particularly, we pad the set of target table body rows to size M with ⟨∅⟩. Afterwards, we determine the target assignments via the bipartite matching between the generated table body rows and targets:
f̂ = argmin f∈F(M)
M∑
m=1
C(Yf(m),Pm), (15)
where F(M) denotes the set of all M ! one-to-one mapping functions and f(·) is a function aligning
the m-th generated table body row to the f(m)th target one. The optimal matching can be efficiently determined with the Hungarian algorithm (Kuhn, 1955). More specifically, the matching cost C(·) takes into account the token level probability, which is defined as follows:
C(Yf(m),Pm) = − N∑
k=1
1{Y ̸=∅}p m k (y f(m) k ),
(16) where N is the length of the first cell in Yf(m) and pmk (y f(m) k ) is the predictive probability of the k-th target token yf(m)k of the m-th table body row. We ignore the score from matching predictions with ⟨∅⟩, so as to ensure that each generated row can be aligned with a non-empty target as possible.
For example, in Figure 3, our model generates the first cells of six table body rows, where the first one is ⟨∅⟩ token and the others are player names. Then we assign each generated table body row to a target one according to the above-mentioned bipartite matching. In this example, we can find an optimal matching, with a mapping function f̂ satisfying that f̂(1) = 5, f̂(2) = 4, ..., f̂(6) = 1. Note that there are two “Stephen Curry” occurring in row 2 and row 4, but are aligned to different targets due to the one-to-one matching. In this way, we can guarantee that supervision signal for generating each table body row is unique, alleviating the generation of duplicate rows.
Finally, through the above target row assignments, we can calculate Lb as follows:
Lb = − M∑
m=1
|Yf̂(m)|∑
k=1
logp̂mk (y f̂(m) k ), (17)
where p̂mk (·) is the predictive distribution of the m-th generated table body row at the timestep k, and yf̂(m)k is the k-th token in the assigned target row.
Particularly, inspired by the recent studies (Carion et al., 2020; Ye et al., 2021; Xie et al., 2022), when yf̂(m)k = ⟨∅⟩, we multiply its token-level loss with a predefined factor to down-weight its effect, so as to reduce the negative effect of excessive ⟨∅⟩ tokens.

heading: 5 Experiments

heading: 5.1 Setup
text: Datasets Following the previous work (Wu et al., 2022), we conduct experiment on four commonlyused datasets for table-to-text generation: Rotowire (Wiseman et al., 2017), E2E (Novikova et al., 2017), WikiTableText (Bao et al., 2018), and WikiBio (Lebret et al., 2016). As the main dataset of our experiments, Rotowire has two types of tables named Team and Player. In Rotowire, each instance has multiple columns while the other three datasets have only two columns. We use the processed datasets from (Wu et al., 2022). The dataset statistics are listed in Appendix A.
Implementation Details We initialize our model with the pre-trained BART-base (Lewis et al., 2020), which consists of 6 encoder layers and 6 decoder layers. The number of multi-head attention is 12, the dimension of embedding and hidden state is 768, and the dimension of feed-forward network is 3,072. We reuse the vocabulary from the pre-trained BART-base model, whose size is 51,200. We use the Adam (Kingma and Ba, 2015) optimization algorithm with a fixed maximum number of tokens as 4,096. For different datasets, we set different numbers of row embeddings according to the maximum row numbers in training sets. We train a separate model on each dataset and select the model with the lowest validation loss. Hyperparameter settings are shown in Appendix B.
Baselines We compare our model with the following baselines mentioned in (Wu et al., 2022):
• Sent-level RE This model uses an existing method of relation extraction (RE) (Zhong and Chen, 2021) to extract information based on predefined schemas. It takes the first column and data cells as entities and the types of table header cells as relations.
• Doc-level RE It applies the same RE method,
except that it predicts the relations between entities within multiple sentences.
• NER It is a BERT-based (Devlin et al., 2019) entity extraction method that considers data cells in each table as entities and its first column cells as entity types.
• Seq2Seq (Wu et al., 2022) It is a Transformer based seq2seq model that models the generation of a table as a sequence.
• Seq2Seq-c (Wu et al., 2022) This model is a Seq2Seq variant, where the cell number of each table body row is limited to the same as that of table header.
Evaluation We use the same evaluation script from (Wu et al., 2022). We adopt the F1 score as the evaluation measure, which is calculated in the following way: the precision and recall are first computed to get table-specific F1 scores, which are then averaged to obtain the final score. Here, precision is defined as the percentage of correctly predicted cells among the generated cells, and recall is defined as the percentage of correctly predicted cells among target cells. Particularly, the F1 score is calculated in three ways: exact match that matches two cells exactly, chrf score that calculates character-level n-gram similarity, and BERTscore that calculates the similarity between BERT embeddings of two cells.
For Rotowire, we report the F1 scores of the first column, table header and data cells, which refer to row header F1, column header F1 and non-header cells F1 in (Wu et al., 2022). For the other three datasets, there are only fixed two columns, so the F1 score of table header is not calculated. For data cells, we use not only the content but also the table header/the first column cells to ensure that the cell
is on the right column/row. Note that these metrics are insensitive to the orders of rows and columns. Besides, we calculate the error rate to represent the percentage of erroneous format tables.

heading: 5.2 Main Results
text: Table 2 reports the results on the Team and Player subsets of Rotowire. We observe that our model consistently outperforms all baselines in terms of three kinds of F1 scores. Particularly, in terms of data cell F1, which is the most difficult of the three kinds of F1 scores, ours achieves significant improvements. Besides, note that both Seq2Seq-c and our model enforce the number of cells in each table body row to be the same as that of table header, so their error rates are 0. Table 4 shows the results on E2E, WikiTableText and WikiBio. Likewise, our model outperforms almost all baselines.
We also provide a case in Appendix C to visually show the effectiveness of our model.

heading: 5.3 Inference Efficiency
text: We compare the inference efficiency of different models. From Table 3, we observe that ours is significantly more efficient than baselines, due to its advantage in the parallel generation of table body rows.
To investigate the effect of speedup on different types of tables, we carry out experiments on the Rotowire Player dataset. We define row-to-column ratio as the row number divided by the column number and measure the speedup with different row-to-column ratios. The results depicted in Figure 4 demonstrate that our model exhibits a linear improvement as the row-to-column ratio increases.

heading: 5.4 Error Propagation Analysis
text: As analyzed in Introduction, our model is able to better alleviate the error propagation issue than previous models. To verify this, we conduct experiments on the longest dataset Rotowire Player, and then compare the performance of our model and Seq2Seq-c. From Figure 5, we observe that ours always outperforms the baseline model. Particularly, with the number of table tokens increasing, our model exhibits more significant performance advantages over Seq2Seq-c.

heading: 5.5 Ablation Study
text: We conduct an ablation study on Rotowire to verify the effectiveness of different components of our model. The results are shown in Table 5, involving four variants:
w/o Row Embeddings. We remove row embed-
dings in this variant. From lines 3 and 8, we observe that this variant is completely collapsed. This is reasonable that without row embeddings, the row-specific inputs of table body generator become exactly the same, resulting in the generator failing to generate distinct rows.
w/o Column Embeddings. We remove column embeddings in this variant. From lines 4 and 9, we observe that the data cell F1 decreases a lot. Thus, we also confirm that column embeddings are indeed useful in enhancing the semantic consistency between cells in the same column. The other two scores changed very little, which we believe is due to the fact that table headers and the first columns have no need to refer to the other rows.
w/o Target Assignments. In this variant, we discard the target assignments based on the first cells during training, which makes our model learn to generate table body rows in the original order of targets. As shown in lines 5 and 10, our model exhibits a significant performance drop.
w/o Table Header Generator. In this variant, we simultaneously generate table header and table body rows in parallel. Consequently, the variant can not leverage the information of generated table header during the process of generating table body rows, and thus exhibits worse performance than the original model. This result proves that it is reasonable to distinguish the generation of table header and table body rows.

heading: 6 Conclusion
text: In this paper, we propose a Seq2Seq&set model for text-to-table generation, which first outputs a table header, and then table body rows. Most importantly, unlike the previous study (Wu et al., 2022), we model the generation of table body rows as a set generation task, which is able to alleviate not only the wrong bias caused by the predefined order during training, but also the problem of error propagation during inference. Experimental results show that our model gains significant performance improvements over the existing SOTA.
Limitations
Our model is currently suitable for generating ordinary tables with attribute names and records, but it may struggle with more complex table formats that involve merged cells. To improve the flexibility of our model, we plan to investigate more versatile forms of table representation.
Another limitation of our model is that our model training involves longer training time, compared with seq2seq baselines. This may be due to the inherent instability of target assignments. In the future, we will explore refining the model training by reducing the target assignment instability.
The existing datasets for this task is relatively simple, and in the future we will conduct experiments on more complex datasets that require reasoning, such as WebNLG (Gardent et al., 2017).
Ethics Statement
This paper proposes a Seq2Seq&set model for textto-table generation. We take ethical considerations seriously and ensure that the research and methods used in this study are conducted in an ethical and responsible manner. The datasets used in this paper are publicly available and have been widely adopted by researchers for testing the performance of text-to-table generation. This study does not involve any data collection or release, and thus there exist no privacy issues. We also take steps to ensure that the findings and conclusions of this study are reported accurately and objectively.

heading: Acknowledgement
text: The project was supported by National Natural Science Foundation of China (No. 62276219), Natural Science Foundation of Fujian Province of China (No. 2020J06001), Youth Innovation Fund of Xiamen (No. 3502Z20206059). We also thank the reviewers for their insightful comments.

heading: A Dataset Statistics
text: Table 6 shows the statistics of the datasets we used. We list the numbers of instances in training, validation, and test sets and the average number of BPE tokens per instance. We also give the average numbers of rows and columns per instance.

heading: B Hyper-parameter Settings
text: Table 7 shows the hyper-parameter settings in our experiments. We set the hyper-parameters by referring to the existing work and choosing values that result in the best performance (measured in data cell F1) on the validation sets.

heading: C Case Study
text: Figure 6 shows a case comparison between Seq2Seq-c and our Seq2Seq&set. Although the first three table body rows generated by Seq2Seq-c are almost correct, the others are duplicated, which also frequently occurs in other text generation tasks. In contrast, our model can handle this case correctly because ours generates table body rows in parallel and thus is not affected by other rows.
ACL 2023 Responsible NLP Checklist

heading: A For every submission:
text: 3 A1. Did you describe the limitations of your work?
7
3 A2. Did you discuss any potential risks of your work? 8
3 A3. Do the abstract and introduction summarize the paper’s main claims? 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts? 5
3 B1. Did you cite the creators of artifacts you used? 5
3 B2. Did you discuss the license or terms for use and / or distribution of any artifacts? 5
3 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)? 5
3 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? 8
3 B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? 5
3 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. 10
C 3 Did you run computational experiments? 5
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? 5
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? 5
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? 5
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.)? 5
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: In the future, we will explore refining the model training by reducing the target assignment instability. The existing datasets for this task is relatively simple, and in the future we will conduct experiments on more complex datasets that require reasoning, such as WebNLG (Gardent et al. , 2017)