Data-to-text task aims to generate a natural language description from structural or semi-structural data, such as tables Wiseman et al. (2017), Abstract Meaning Representation (AMR) graphs Banarescu et al. (2013)
, and Knowledge Graphs (KG)Cheng et al. (2020). It helps people get the key points of the input data and makes the stored information accessible to a broader audience of end-users. There have been several practical application scenarios in this field, such as biography generation Lebret et al. (2016), basketball news generation Wiseman et al. (2017), and advertising text generation Shao et al. (2019). This paper focuses on generation from graph structures in AMR and KG, referred to as graph-to-text.
In recent years, encoder-decoder with the cross-attention mechanism has been the de facto framework for graph-to-text tasks (shown in Figure 1(a)). Given an input graph, the encoder first computes vector representations for the graph nodes. On the decoding side, Input Graph (IG) context vector is obtained via cross-attention based on the partially Generated Text (GT) at each time step, then the next target token is finally predicted. Unlike conventional text-to-text tasks, the structural nature of the input graph makes it unsuitable to naively apply sequential encoder-decoder architecture to the graph-to-text task. To alleviate this issue, recent studies Song et al. (2018); Damonte and Cohen (2019); Cai and Lam (2020) proposed to utilize the graph encoder to capture the input graph structure. These works have demonstrated that explicitly modeling the graph structure can bring benefits to the model performance.
Although equipped with the structure-aware modeling, it is still hard for the encoder to capture all specialized information for graph-to-text generation. It is evidenced by recent studies (Liu et al., 2019; Li et al., 2021) that a vanilla structural encoder cannot capture the accurate semantic representation of the input structural data effectively. Auxiliary supervision has been shown to be helpful, but effective auxiliary tasks are not easy to design and may not generalize well to different datasets. We suspect that it is challenging for the encoder to encode all relevant information into node representations in a single forward pass for all the decoding steps, especially if the input graph structure is complex. Besides the encoder side, few works have focused on the decoder side for graph-to-text tasks. Considering the ordinary cross-attention mechanism, the representations of input data obtained from the encoder are still treated as an unordered node representation sequence. We conjuncture that this plain cross-attention does not take full advantage of the input graph structure and therefore may harm the model performance.
Current models with graph encoder and cross-attention may yield inaccurate input graph context representation due to the deficiency on both encoder and decoder as we discussed before. To tackle the above problems and avoid introducing auxiliary tasks, we propose a novel Structure-Aware Cross-Attention (SACA) mechanism. Apart from the plain cross-attention, our SACA re-encodes the input graph conditioning on the newly generated context in a structure-aware fashion. Other than a single forward pass, specialized representations from the source side are built adaptively at each decoding step, which makes the decoder easily exploit relevant-only information for prediction. More specifically, as shown in Figure 1(b), we construct a joint graph, in which we explicitly treat the generated text context vector as an additional node and connect it with nodes in the input graph at each decoding step. We implement SACA using the relational graph attention network (RGAT, Shaw et al. 2018). Furthermore, we stack multiple layers of SACAs to perform deep interactions between the generated text context vector and input node representations. Finally, we fetch the node representation corresponding to the newly added node as the structure-enhanced input graph context to predict the target token.
In practice, we notice that some nodes become irrelevant and uninformative as the decoding goes on. These nodes are distracting and can disturb the generation process. Intuitively, the decoder should dynamically discard the unrelated parts of the graph at different decoding steps. In other words, the joint graph structure should be dynamically adjusted. To this end, we adapt SACA and propose its variant Dynamic Graph Pruning (DGP) mechanism (shown in Figure 1(c)). DGP prunes the structure of the joint graph via the gate mechanism to achieve sparse connections between the nodes based on the generated text context.
We conduct experiments on two graph-to-text datasets, LDC2020T02111https://catalog.ldc.upenn.edu/LDC2020T02 and ENT-DESC Cheng et al. (2020), to verify the effectiveness of the proposed approach. Empirical results show that our proposed methods achieve new state-of-the-art results on the two datasets. Further experiments indicate that SACA and DGP do not reduce the diversity of the generated text and can better handle complex graphs. Meanwhile, additional investigation reveals that SACA and DGP only bring minor increase on the model size and inference time.
2 Related Works
Graph-to-text is a challenging task which aims at generating a descriptive text from the structured knowledge, such Knowledge Graph (KG), and Abstract Meaning Representation (AMR) graphs. It is helpful for interpretability of KGs in general Schmitt et al. (2020) and knowledge-based question answering Hui et al. (2022); Wang et al. (2022); Fu et al. (2020); Qin et al. (2022).
In recent years, most graph-to-text methods have been built based on the encoder-decoder architecture. This kind of method usually consists of a structural encoder and a decoder. The structural encoder aims to model the structure information into the representation of the input graph. Song et al. (2018) first propose the graph recurrent networks (GRNs) to encode the AMR node directly. And then, some works Shi et al. (2020); Chen et al. (2020)
introduce the Graph Neural Networks (GNNs) as the structural encoder, which updates the representations of nodes based on their immediate neighbors. To integrate both local and non-local features and learn a better structural representation of a graph,Guo et al. (2019) introduce the dense connection, allowing deeper GCNs. Unlike the local information aggregation scheme, Zhu et al. (2019); Cai and Lam (2020) propose the Graph Transformer that uses explicit relation encoding and allows direct communication between two distant nodes.
A recently proposed neural abstractive Multi-Document Summarization (MDS) model, GraphSummLi et al. (2020), also considers the input graph structure during decoding. The biggest difference between Graphsum and our proposed SACA is that the former only introduces one graph attention layer in each decoder layer. SACA, on the other hand, injects graph structure into decoding by re-encoding the input graph. Specifically, it re-computes the input graph representation by conditioning it on the newly generated text at each decoding step.
Recent approaches try to apply the Pre-trained Language Models (PLMs) Kenton and Toutanova (2019); Raffel et al. (2019) into the graph-to-text generation. Particularly, Ribeiro et al. (2021) propose to utilize the adapter method Pfeiffer et al. (2020) to encode graph structure into PLMs and only train graph structure-aware adapter parameters. In this way, they avoid catastrophic forgetting while maintaining the topological structure of the graph.
We expect that developing graph-to-text generation should benefit from the recent advance on pre-trained language models (PLMs) Lewis et al. (2020); Raffel et al. (2019). To explicitly encode the input graph structure into PLMs while alleviating the catastrophic forgetting problem, we consider SA-RGCN Ribeiro et al. (2021) as our baseline model. SA-RGCN is an adapter method to encode graph structure into PLMs. The overall illustration of our model architecture is shown in Figure 2(a). In this section, we first introduce how to represent the input graph and the architecture of our baseline SA-RGCN. Then, we depict our proposed Structure-Aware Cross-Attention (SACA) in details. Lastly, we adapt SACA and propose its variant Dynamic Graph Pruning (DGP).
3.1 Graph Representation
Let denote a multi-relational and directed graph with nodes and labeled edges , where is the relation type. Following previous work Beck et al. (2018), we convert each input graph into a Levi graph , which is an unlabeled and connected bipartite graph. Specifically, each labeled edge is transformed into two unlabeled edges . In addition, we add a reverse edge for each default edge . Therefore, each Levi graph contains two type relations , where and denote the default and reverse edge, respectively. To better take advantage of the PLMs, we convert each into a new token graph , where each token of a node in becomes a node .
3.2 Pretrained LMs with Structural Adapters
To inject graph structural bias into PLMs, we incorporate the structural adapter Ribeiro et al. (2021) into the PLMs encoder. As shown in Figure 2 (a), we add a structural adapter after each transformer encoder block on the encoder. Figure 2 (b) illustrates the architecture of a structural adapter, in where a relational GCN (RGCN) Schlichtkrull et al. (2018) layer computes the node representation based on the local neighborhood of node . Formally, at each layer , given the encoder layer representation , a structural adapter computes the representation for by the following:
where denotes layer normalization. is the sef of immediate neighbors under relation . encodes the edge type between the nodes and .
is the activation function.
We add an FNN adapter after each transformer decoder block to adapt the language model to the graph-to-text task. Given the output of the th transformer decoder block, the adapter representation is computed as:
where and denote learnable parameters.
3.3 Structure-Aware Cross-Attention
We argue that the input graph context representation obtained by the plain cross-attention may be inaccurate. The reason is twofold. First, it is not easy for the graph encoder to capture all specialized information required for generation in a single forward pass. Therefore, a single encoder without any auxiliary assistant may not be effective in capturing the accurate semantic representation Liu et al. (2019); Li et al. (2021). In other words, the graph representation encoded by the graph encoder may be inaccurate. Second, during decoding, the decoder treats structural data as an unordered node sequence, which ignores the input graph structure. However, the graph structure has been proven to play an essential role in the graph representation and may offer clues about which nodes are more related to the generated text context.
To tackle the above challenge, we propose a Structure-Aware Cross-Attention (SACA) mechanism, which re-encodes the input graph representation by conditioning on the newly generated context. Specifically, we first build a joint graph, in which we view the generated text (GT) context as a new node and explicitly connect it to each node in the input graph at each decoding step. The corresponding reverse edges are also added. The joint graph can be formulated as , where and . We use the representations from the encoder for the node from and the hidden state from the last transformer decoder block as the representation for the GT context node.
To induce the representations for the nodes in the joint graph and facilitate introducing Dynamic Graph Pruning (in Section 3.4), we consider graph neural network built on graph attention framework (GAT) Shaw et al. (2018). Moreover, we employ the relational graph attention network (RGAT) implemented by Shaw et al. (2018) to model the relation between neighbor nodes. Specifically, at each RGAT layer , we update the representation of each node by:
where means the embedding of the relation between node and . denotes the hidden dimension of RGAT. Finally, the representation vector corresponding to the GT context node is fetched and used as the structure-enhanced input graph context vector for token prediction.
In conclusion, SACA provides two advantages. First, it re-encodes the input graph by conditioning its representation on the newly generated context. As a result, we build specialized representations which make it easier for the decoder to exploit relevant-only information for prediction at each decoding step. Second, the re-encoding explicitly injects structural bias into input graph context modeling, helping the decoder obtain a more accurate input graph context vector. The proposed SACA can be plugged after the last transformer decoder block as shown in Figure 2 (a).
3.4 Dynamic Graph Pruning
In practice, we notice that some nodes become irrelevant and uninformative as the decoding goes on. These unrelated nodes are distracting and can even disturb the subsequent generation. Intuitively, the decoder should dynamically prune the joint graph at different decoding steps. For this purpose, we adapt SACA and propose its variant Dynamic Graph Pruning (DGP) mechanism, which aims to dynamically drop the redundant nodes in the joint graph according to the generated text during decoding. The DGP employs the gate mechanism to sparse the connection between a node and its immediate neighbors in the joint graph to achieve graph pruning. Specifically, at each decoding step , for each node in the joint graph, we formulate its gate as bellow:
where , , and are learnable parameters. And is the representation of node and is the decoder hidden state at decoding step , which is usually considered as the representation of the generated text context. The value of gate decides whether the node should be dropped or not. Correspondingly, we apply the gate value to multiple SACA layers invariably by modifying the attention weights in SACA (Equation 5) as follows:
Intuitively, if the value of gate is close to , the connections between node with all its immediate neighbors will be largely weaken. That is, the node is removed from the joint graph. Specifically, the attention score measures the relevance between any two nodes, and , in the joint graph, while the gate models the relevance between the node and the generated text context .
As a shown example in Figure 2 (c), the red node represents the main entity. Initially, the main entity connects with all its neighbor nodes. As the decoding goes on, some nodes are redundant for the subsequent generation. For example, the nodes “actor“ has been described, and node “voice actor“ is also covered by the generated text. Therefore, DGP discards these nodes by giving them gates with small values.
We observed that the values of the gates calculated by Equation 7 are almost equal to
, indicating that the model does not actively learn to prune a graph. Inspired byXue et al. (2020), we further introduce a regularization item, encouraging the network to turn off more gates and generate more sparse connections between nodes in the input graph. We formulate it as follows:
where . means norm regularizer.
|LDGCN Zhang et al. (2020b)||34.3||38.2||63.7||-||-|
|SPRING Bevilacqua et al. (2021)||44.9||-||72.9||-||-|
|FINETUNE Ribeiro et al. (2021)||41.6||-||70.4||78.5||96.0|
|ADAPT Ribeiro et al. (2021)||43.0||-||71.3||79.3||96.2|
|SA-RGCN Ribeiro et al. (2021)||48.0||-||73.2||80.1||96.3|
|S2S Bahdanau et al. (2015)||6.8||10.8||-||40.7||10.0|
|GraphTransformer Koncel-Kedziorski et al. (2019)||19.1||16.1||-||54.3||21.4|
|GRN Beck et al. (2018)||24.4||18.9||-||55.5||21.3|
|GCN Marcheggiani and Perez-Beltrachini (2018)||24.8||19.3||-||56.2||21.8|
|DeepGCN Guo et al. (2019)||24.9||19.3||-||56.2||21.8|
|MGCN + CNN Cheng et al. (2020)||26.4||20.4||-||57.4||24.2|
Given a reference output and an input graph , we use the cross-entropy loss as the objective function of graph-to-text generation:
Finally, the overall objective function consists of two parts:
where is a tunable hyper-parameter and is used to make a trade-off between the cross-entropy loss and the regularization item. Intuitively, the object encourages the model to learn how to prune the graph, and the trains the model to generate the text according to the graph and restrains DGP from pruning too much.
We demonstrate the effectiveness of our models on two graph-to-text datasets: LDC2020T02 and ENT-DESC Cheng et al. (2020) LDC2020T02 is an AMR-to-Text dataset and has 55,635/1,722/1,898 instances for training, development, and testing. We follow Ribeiro et al. (2021) to preprocess the AMR graphs and tokenize the sentences. Each instance contains a sentence and an AMR graph. ENT-DESC is a large-scale and challenging dataset generating text from the Knowledge Graph (KG-to-Text). Each instance contains a KG consisting of a main entity and a few topic-related entities. The target text consists of sentences that verbalize the main entity in KG. ENT-DESC lacks explicit alignment between the input and the output. Therefore, some knowledge in the input graph may be noise. We follow official training, development, and test splits of 88,650/11,081/11,081 instances. Table 1 summarizes the detailed statistics of LDC2020T02 and ENT-DESC.
Our implementation is based on Hugging Face Wolf et al. (2019)
. The RGCN and RGAT are implemented based on PyTorch GeometricFey and Lenssen (2019). We initialize our models by T5 Raffel et al. (2019). To make a fair comparision, we following the same experimental setting with SA-RGCN Ribeiro et al. (2021). We set the hidden dimensions of both Structural Adapter and SACA to . And we use T5 for all experiments on ENT-DESC and T5 on LDC2020T02 for a fair comparison with baselines. We use the AdamW optimizer Loshchilov and Hutter (2018) and employ a linearly decreasing learning rate schedule without warm-up. The learning rate is fixed as . We set the training batch size as for all experiments. We freeze the T5 parameters and only update the newly added parameters during training. We tune the hyper-parameter in Equation 11 from the set , and select the best one on the development set. We stack RGAT layers in Structure-Aware Cross-Attention. During decoding, we use beam search with a beam size . We use BLEU Papineni et al. (2002) for the early stopping criterion. All experiments are trained on Nvidia Tesla V100 32GB GPUs.
Following previous works, on both datasets, we evaluate the results with BLEU Papineni et al. (2002), METEOR Denkowski and Lavie (2011), and ChRF++ Popović (2015) on both datasets. On LDC2020T02, following Ribeiro et al. (2021), we utilize the meaning () component of the -score Opitz and Frank (2021) to measure how well the source AMR graph can be reconstructed from the generated sentence (refer to A.1 for more details). We use BERTScore Zhang et al. (2020a) allowing a semantic evaluation that depends less on the surface forms. On ENT-DESC, We add ROUGE-L Lin (2004) and employ PARENT Dhingra et al. (2019) for evaluating the faithfulness. We conduct experiments over 4 different seeds and report the average scores on them.
4.3 Main Results
We compare our method with recent state-of-the-art methods (please refer to A.4 for more details). Table 2 summarizes the results on LDC2020T02 and ENT-DESC test sets. FINETUNE is a method that transforms the input graph into a sequence and finetunes T5 directly. It does not consider the input graph structure. For LDC2020T02, our method outperforms the previous state-of-the-art model by BLEU and ChRF++. Compared with our implemented SA-RGCN, we improve METEOR. Moreover, our method raises , which indicates that it can generate more faithful sentences to the input graphs. The improvement on BERTScore shows that the sentence generated by our method is more similar to the ground truth on the semantic level. For ENT-DESC, we notice FINETUNE performs better than all previous methods. SA-RGCN, which encodes graph structure into T5, furtherly improves the performance. And our model exceeds all previous works and achieves new state-of-the-art results on all metrics. The above results indicate that our proposed methods can improve the model on fluency and faithfulness.
|w/o SACA & DGP||47.20||45.05||80.01||23.38||71.69|
4.4 Analysis and Discussion
The overall performance on the two datasets shows the superiority of our proposed Structure-Aware Cross-Attention (SACA) and Dynamic Graph Pruning (DGP). To demonstrate the effectiveness of each component, we conduct ablation studies on LDC2020T02 development sets and minus one particular component at a time to understand its impact on the performance. Especially, w/o DGP denotes we remove the dynamic graph pruning module and the training objective . ADAPT and w/o StrucAdapt denote replacing each structural adapter in SA-RGCN’s and our encoders with an FNN adapter, respectively. W/o StrucAdapt means that the model only considers the structural information during decoding. The results are summarized in Table 3. Particularly, we observe the performance drops after removing SACA or DGP. This indicates that injecting the structural information into input graph context modeling (SACA) and dynamically removing the redundant nodes (DPG) are beneficial. Regarding the score, our model and ADAPT are close to GOLD. The AMR parser utilized by , ADAPT as well as our method are all initialized by T5. And the AMR paring and AMR-to-Text are dual tasks actually. Therefore, the score is biased and the results of our model and ADAPT are somehow inflated. Additionally, we utilize Distinct-1 and Distinct-2 Li et al. (2016) to evaluate the diversity of the output text. We observe that SACA and DGP have little effect on Distinct-1 and Distinct-2. This implies that they will not reduce the diversity of the output text.
We notice that, compared with ADAPT, w/o StrucAdapt shows a slight improvement. This indicates it is necessary to explicitly model the graph structure in the encoder, even though structural bias has been injected into the input graph context modeling during decoding. We believe this may be attributed to SACA relying on the input graph representation encoded by the encoder. Because our SACA is designed to exploit the relevant-only information for prediction, it re-encodes the input graph by conditioning its representation on the newly generated context. Therefore, the initial representation for the input graph is important.
Impact on the parameter and speed
Furthermore, we investigate the impact of SACA and DPG on the model parameters and inference speed on LDC2020T02 development. Specifically, we calculate the additional parameters of each model with respect to T5. And we set the batch size to to calculate the average decoding time for generating all examples. The results summarized in Table 4 indicate that SACA and DGP only bring minor increase on the model size and inference time.
|# Additional Params (million)||Latency (s)|
|+ SACA||39.21 (5.0%)||1.54|
|+ SACA & DGP||41.31 (5.0%)||1.55|
Impact on the Graph Properties
To examine the robustness of our proposed methods, we investigate the model’s performance concerning different graph properties (graph size, graph diameter, and reentrancies) on LDC2020T02 and ENT-DESC. Following previous works Cheng et al. (2020); Ribeiro et al. (2021), we use BLEU as the metric. The results are summarized in Table 5 and Table 6, respectively. For LDC2020T02, we firstly note that the BLEU scores decrease as the graph size increases since the larger graph is often complex. Our method achieves a clear improvement when handling graphs with nodes. And then we observe that the BLEU gap between our method and SA-RGCN becomes larger for a relatively larger graph diameter. Reentrancies are the nodes with multiple parents. A graph with more reentrancies is typically more complex Wang et al. (2020). As shown in the last section in Table 5, our method has an improvement of BLEU points compared to SA-RGCN when graphs contain reentrancies. To sum up, the results on the LDC2020T02 dataset show the advantage of our model in dealing with the AMR graph with more complex structures.
As shown in Table 6, both models perform differently on ENT-DESC than on LDC2020T02. First, we notice that both models perform the best when the graph size is between and , and they perform poorly when the graph size is too small or too large. Cheng et al. (2020) also observed the finding, and they believe this is due to the insufficient or very noisy input information for generation. Additionally, both models perform better when graph diameter or number of the reentrancies increase. The reason is that, in the ENT-DESC, the knowledge graph with a small diameter or number of the reentrancies contains more noisy information for the generation. Please refer to A.2 for more details. The BLEU gap between our method and SA-RGCN is the largest when the graph diameter or the number of reentrancies . The above results demonstrate that our approach makes SA-RGCN better at handling complex knowledge graphs.
We investigate how the model behaves on different types of graphs (AMR and KG). And the results demonstrate that our model deals better with complex structures. We believe the improvement comes from two aspects. First, on the one hand, it is challenging for an encoder to encode all relevant information into node representations in a single forward pass, especially if the graph structure is complex. On the other hand, the re-encoding in SACA makes the decoder easily exploit the relevant-only information for prediction and explicitly injects the structural information at each decoding step. Second, DGP dynamically removes the nodes which are redundant for the subsequent generation, which makes the decoder pay more attention to the relevant nodes.
|GraphWriter||14.13 0.10||18.92 0.28||27.61 0.16|
|Ours||15.59 0.35||19.70 0.21||28.47 0.14|
4.5 Generalization Study
Institutionally, our proposed methods can not only be applied to PLMs but also RNN based models. In other words, we can easily combine the SACA and DGP with previous RNN based works. To examine the generalization of SACA and DGP, we choose GraphWriter Koncel-Kedziorski et al. (2019) as the baseline, which consists of a multi-layer graph transformer encoder and an attention-based decoder with a copy mechanism. Further, to make a fair comparison, we conduct the generalization experiment on AGENDA dataset Koncel-Kedziorski et al. (2019). We simply replace the plain cross-attention in GraphWriter with our proposed SACA. Additionally, we add the DGP layer before the SACA. The experiments are under the same settings as described in GraphWriter. As shown in Table 7, we observe that our proposed model significantly improves the performance of GraphWriter. The results indicate that SACA and DGP are not only effective well on PLMs-based models but also potent for RNN-based models.
4.6 Human Evaluation
Considering that the knowledge graph is more readable than AMR, we do human evaluations on the ENT-DESC test set to examine whether human judgments corroborate improvements in automatic evaluation metrics. FollowingCheng et al. (2020), from outputs generated by the baseline model SA-RGCN and our final model (Ours). We distribute the outputs of different systems to three annotators with linguistic backgrounds. The annotators have no knowledge in advance about which model the generated text comes from. Specifically, we give each participant all main entities’ neighbors, 1-hop and 2-hop connections between main entities, and topic-related entities as references. They are required to score the generated text from 1 to 5 in terms of three criteria: Fluency (is the sentence fluent?), Grammar (is the sentence grammatical?), and Authenticity (is the sentence more related to the input graph?). For each criterion, we calculate the final score by averaging the scores from all annotators. As shown in Figure 3, our model outperforms the baseline SA-RGCN on Fluency and Grammar metrics. For Authenticity, the improvement is more significant. The performance validates the benefit of our proposed SACA and DGP modules in capturing more accurate input graph context representations. We supply a case study in A.3.
In this work, we make two main contributions. First, we propose Structure-Aware Cross-Attention (SACA) to make decoder easily exploit relevant-only information for prediction. Apart from the plain cross-attention, SACA re-encodes the input graph conditioning on the newly generated context while explicitly considering the input graph structure. The second one is that we adapt SACA and propose its variant Dynamic Graph Pruning (DGP) mechanism. In detail, the DGP dynamically prunes the structure of the joint graph at different decoding steps according to the generated text. Experimental results conducted on two graph-to-text datasets, LDC2020T02 and ENT-DESC, show the effectiveness of our method. The empirical and analysis results on both datasets show that the proposed methods can improve the model’s performance on complex graphs while only bringing minor increase on the model size and inference time.
- Neural machine translation by jointly learning to align and translate. In Proc. of ICLR, Cited by: 1st item, Table 2.
- Abstract meaning representation for sembanking. In Proceedings of the 7th linguistic annotation workshop and interoperability with discourse, Cited by: §1.
- Graph-to-sequence learning using gated graph neural networks. In ACL, Cited by: 3rd item, §3.1, Table 2.
- One SPRING to rule them both: symmetric AMR semantic parsing and generation without a complex pipeline. In Proc. of AAAI, Cited by: 2nd item, Table 2.
- Graph transformer for graph-to-sequence learning. In Proc. of AAAI, Cited by: §1, §2.
- KGPT: knowledge-grounded pre-training for data-to-text generation. Cited by: §2.
- ENT-DESC: entity description generation by exploring knowledge graph. In EMNLP, Cited by: 6th item, §A.2, §1, §1, Table 2, §4.1, §4.4, §4.4, §4.6.
- Structural neural encoders for amr-to-text generation. In Proc. of AACL, Cited by: §1.
- Meteor 1.3: automatic metric for reliable optimization and evaluation of machine translation systems. In Proceedings of the sixth workshop on statistical machine translation, Cited by: §4.2.
- Handling divergent reference texts when evaluating table-to-text generation. In Proc. of ACL, Cited by: §4.2.
- Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, Cited by: §4.2.
- A survey on complex question answering over knowledge base: recent advances and challenges. arXiv preprint arXiv:2007.13069. Cited by: §2.
- Densely connected graph convolutional networks for graph-to-sequence learning. Transactions of the Association for Computational Linguistics. Cited by: 5th item, §2, Table 2.
- SSQL: injecting syntax to question-schema interaction graph encoder for text-to-SQL parsers. In Findings of the Association for Computational Linguistics: ACL 2022, Dublin, Ireland, pp. 1254–1262. Cited by: §2.
- BERT: pre-training of deep bidirectional transformers for language understanding. In Proc. of AACL, Cited by: §2.
- Text generation from knowledge graphs with graph transformers. In Proc. of AACL, Cited by: 2nd item, Table 2, §4.5.
- Neural text generation from structured data with application to the biography domain. In EMNLP, Cited by: §1.
- BART: denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. Cited by: §3.
- A diversity-promoting objective function for neural conversation models. In Proc. of NAACL, Cited by: §4.4.
- Improving encoder by auxiliary supervision tasks for table-to-text generation. In ACL, Cited by: §1, §3.3.
- Leveraging graph to improve abstractive multi-document summarization. In Proc. of ACL, Cited by: §2.
- Rouge: a package for automatic evaluation of summaries. In Text summarization branches out, Cited by: §4.2.
- Hierarchical encoder with auxiliary supervision for neural table-to-text generation: learning better representation for tables. In Proc. of AAAI, Cited by: §1, §3.3.
- Decoupled weight decay regularization. In ICLR, Cited by: §4.2.
- Deep graph convolutional encoders for structured data to text generation. In Proceedings of the 11th International Conference on Natural Language Generation, Cited by: 4th item, Table 2.
- Towards a decomposable metric for explainable evaluation of text generation from AMR. In Proc. of EACL, Cited by: §A.1, §4.2.
- Bleu: a method for automatic evaluation of machine translation. In ACL, Cited by: §4.2, §4.2.
- MAD-X: An Adapter-Based Framework for Multi-Task Cross-Lingual Transfer. In EMNLP, Cited by: §2.
- . In Proceedings of the Tenth Workshop on Statistical Machine Translation, Cited by: §4.2.
- A survey on text-to-sql parsing: concepts, methods, and future directions. arXiv preprint arXiv:2208.13629. Cited by: §2.
Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683. Cited by: §2, §3, §4.2.
- Structural adapters in pretrained language models for AMR-to-Text generation. In Proc. of EMNLP, Cited by: §A.4, §2, §3.2, Table 2, §3, §4.1, §4.2, §4.2, §4.4.
- Modeling relational data with graph convolutional networks. In The Semantic Web - 15th International Conference, ESWC 2018, Heraklion, Crete, Greece, June 3-7, 2018, Proceedings, Cited by: §3.2.
An unsupervised joint system for text generation from knowledge graphs and semantic parsing.
Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), Online, pp. 7117–7130. Cited by: §2.
- Long and diverse text generation with planning-based hierarchical variational model. In EMNLP-IJCNLP, Cited by: §1.
- Self-attention with relative position representations. In Proc. of NAACL, Cited by: §1, §3.3.
- G2T: generating fluent descriptions for knowledge graph. In Proc. of SIGIR, Cited by: §2.
- A graph-to-sequence model for amr-to-text generation. In ACL, Cited by: §1, §2.
- Proton: probing schema linking information from pre-trained language models for text-to-sql parsing. In Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 1889–1898. Cited by: §2.
- Amr-to-text generation with graph transformer. Transactions of the Association for Computational Linguistics. Cited by: §4.4.
- Challenges in data-to-document generation. In Proc. of EMNLP, Cited by: §1.
- Huggingface’s transformers: state-of-the-art natural language processing. arXiv preprint arXiv:1910.03771. Cited by: §4.2.
- Not all attention is needed: gated attention network for sequence data. In Proc. of AAAI, Cited by: §3.4.
- BERTScore: evaluating text generation with BERT. In Proc. of ICLR, Cited by: §4.2.
- Lightweight, dynamic graph convolutional networks for amr-to-text generation. In EMNLP, Cited by: 1st item, Table 2.
- Modeling graph structure in transformer for better amr-to-text generation. In EMNLP-IJCNLP, Cited by: §2.
Appendix A Appendix
The (Meaning Preservation) component of the -score Opitz and Frank (2021) is utilized to measure how well the source AMR graph can be reconstructed from the generated sentence. It reconstructs the AMR with a SOTA parser and computes the relative graph overlap of the reconstruction and the source AMR using graph matching. employs the python library amrlib222https://github.com/bjascob/amrlib/tree/0.5.0 (version ) to make AMR parse, where the parser is a T5-based model.
a.2 Distribution on Graph Size
On the ENT-DESC test set, previous study Cheng et al. (2020) and our experimental results (in Table 6) suggest that the model performs the best when the graph size lies in the range of and has a poorer performance when the number of triples is too small or too large. It should be due to the fact that the input information is insufficient or very noisy. However, we find that the model performance increases as the graph diameter and reentrancies increase. For further investigation, we calculate the distribution of graph diameter and reentrancies broken down by graph size, respectively. The results are summarized in Figure 4. As shown in Figure 4(a), the proportion of graphs with size increases as the graph diameter increases. As shown in Figure 4(b), the results on graph reentrancy follow a pattern similar to graph diameter. In a word, in ENT-DESC, the noise decreases as the graph diameter and reentrancies increase, so the model performs better.
a.3 Case Study
As shown in Figure 5, we further take a typical example from our human study to better understand how our method improves the mode’s performance. Given the Knowledge Graph containing the main entity “Andrew Lawrence" and all its related entities, we aim to generate a description about the main entity. We notice that both the baseline and our model can identify the main entity. However, the baseline outputs a sentence describing the relation between “Andrew Lawrence" and “Matthew Lawrence". The relation is not existing in the input graph. Moreover, it repeatedly generates the entity “Brotherly Love" and misses the related entity “Recess". Compared with it, our model generates the sentences faithful to the input graph and correctly covers the main entity and most topic-related entities. We consider this is because the SACA helps the decoder obtain a more accurate input graph context, and the DGP removes the redundant nodes as the decoding stage progresses.
a.4 Baseline Models
On the AMR-to-Text task LDC2020T02, we compare our method with several baselines including:
LDGCN Zhang et al. (2020b) is a a dynamic fusion mechanism, which captures richer non-local interactions by synthesizing higher order information from the input graphs. A weight tied convolutions to reduce memory usage is applied.
SPRING Bevilacqua et al. (2021) casts Text-to-AMR and AMR-to-Text as a symmetric transduction task and proposes a graph linearization and extending a pretrained encoder-decoder model.
On the KG-to-Text task ENT-DESC, we compare our method with several baselines including:
s2s Bahdanau et al. (2015) is a encoder-decoder based model, which allows a model to automatically (soft-)search for parts of a source sentence that are relevant to predicting a target word, without having to form these parts as a hard segment explicitly.
GraphTransformer Koncel-Kedziorski et al. (2019) introduces a novel graph transforming encoder which can leverage the relational structure of such knowledge graphs without imposing linearization or hierarchical constraints.
GCN Marcheggiani and Perez-Beltrachini (2018) proposes an alternative encoder based on graph convolutional networks that directly exploits the input structure.
DeepGCN Guo et al. (2019) introduces a dense connection strategy, which is able to integrate both local and non-local features to learn a better structural representation of a graph.
MGCN + CNN Cheng et al. (2020) is a multi-graph structure that is able to represent the original graph information more comprehensively. We do not report the results of MGCN + CNN + delex. Because it applies the delexicalization technique on the ENT-DESC dataset, which delexicalizes the main entity and topic-related entities by replacing these entities with tokens indicating the entity types and indices. The delexicalization technique greatly boosts their performance on ROUGE-L. They do not release the code about delexicalization, and we can not reproduce it.
What’s more, FINETUNE, ADAPT and SA-RGCN are T5-based models proposed in (Ribeiro et al., 2021).