Reassessing Graph Linearization for Sequence-to-sequence AMR Parsing: On the Advantages and Limitations of Triple-Based (2025)

Abstract: Sequence-to-sequence models are widely used to train Abstract Meaning Representation (Banarescu et al.,2013, AMR) parsers. To train such models, AMR graphs have to be linearized into a one-line text format. While Penman encoding is widely used for this purpose, we argue that it has limitations: 1) for deep graphs, some closely related nodes are located far apart in the linearized text 2) Penman’s tree-based encoding necessitates inverse roles to handle node re-entrancy, doubling the number of relation types to predict. To address these issues, we propose a triple-based linearization method and compare its efficiency by training an AMR parser with both approaches. Although triple is well suited to represent a graph, our results show that it does not yet improve performance on deeper or longer graphs. It suggests room for improvement in its design to better compete with Penman’s concise representation and explicit encoding of a nested graph structure.

## introduction abstract meaning representation (amr) captures text meaning, such as "who does what to whom," and represents it in graphs (see figure 1 ). structured information is easier for computers to process and therefore, amr is widely used in nlp applications, e.g., machine translation @xcite ), text generation @xcite , or human-robot interaction systems @xcite . sequence-to-sequence (seq2seq) approaches have recently gained popularity for amr parsing due to strong performance and easy implementation. for prediction, the model receives an input sentence and outputs an amr graph in text format. to train seq2seq models for amr parsing, graph linearization to represent an amr graph in a one-line text format is a prerequisite. penman encoding is the most common method for amr graph linearization, representing graphs as tree-like structures. it uses variables (e.g. s, s2 in figure 2 ) @xcite . seem-01 -:polarity see-01 :arg1 we :arg2 ever :time :arg0 person :arg1 any :mod nutter :mod dig-01 :arg0 true-01 it :location thing :arg1 acknowledge-01 :arg0 :arg1 figure 3: amr graph without inverse roles. as node ids to manage co-references. in addition, parentheses represent nested structures of amr graphs. however, penman has key limitations to training a seq2seq model: 1) parent-child distance: parent and child nodes may appear far apart in the linearized text, despite being closely connected in the graph. for example, in figure 2 , seem-01 and we are encoded distant in penman format (highlighted in red) despite their proximity in the graph of figure 2. this is observed when a preceding sibling node has a deep sub-graph. we hypothesize that this long distance increases the difficulty of learning strong parent-child connections, especially in deeper graphs. 2) inverse roles: penman represents a graph in a tree-based format. to be specific, when a node has multiple parent nodes (node reentrancy), the child node is duplicated to maintain a single-rooted tree structure. to fit an amr graph into a tree structure, penman introduces inverse roles by rewriting :relation as :relation-of (see figure 2 where inverse roles are highlighted in blue). this increases the number of relations the model must learn, potentially complicating training and reducing model performance. figure 3 shows how inverse roles are unnecessary in a graph-based representation. to address these issues, we propose an alternative triple-based format for amr graph linearization. a triple consists of a parent node, a child node, and a relation type between them, ensuring that parent and child nodes remain adjacent in the linearized text. this format also eliminates inverse roles by replacing (node a, relation-of, node b) with (node b, relation, node a). in the rest of the paper, we compare penman and triple-based formats with examples, highlighting their strengths and limitations in training a seq2seq amr parser. our contributions to seq2seq amr parsing are: triple encoding has been used in relation extraction @xcite @xcite and discourse representation structure (drs) parsing (van noord et al., s instance seem-01 s2 instance see-01 p instance person a instance any n instance nutter d instance dig-01 a2 instance acknowledge-01 t instance thing t2 instance true-01 i instance it w instance we e instance ever s polarity -s arg1 s2 s2 arg0 w s2 arg1 p p mod a p mod n d arg0 p a2 arg0 p a2 arg1 t t2 arg1 t t2 location i s arg2 w s time e 2018a,b). the closest to our approach is van noord et al. (2018a), who convert amr graphs into drs triples. however, their representation differs from ours by mapping amr relations to drs roles and adding extra information that does not exist in amr. in addition, they did not include training an amr parser in their work. while triple encoding is widely used in relation extraction and drs parsing, it has not been used for seq2seq amr parsers. in our work, we propose using it to linearize amr graphs, analyzing its strengths and weaknesses as an encoding method. ## methodology: triple linearization triple representation mitigates the challenges of penman linearization (described in section 1) by encoding a graph as a set of triples. figure 4 illustrates that the parent-child nodes, which were distantly located in figure 2 , are now adjacent in the triple representation (highlighted in red). we hypothesize this helps the model learn direct parentchild relationships, especially in deeper graphs. triples also eliminate inverse roles by reversing the order of two nodes, as shown in figure 4 (highlighted in blue). the triple format, widely used for graph representation (e.g., rdf), aligns better with amr's graph structure than penman's tree-based encoding. its flexibility supports graphs with multiple roots or re-entrancies, making it potentially suitable for broader semantic frameworks. to assess its utility, we trained seq2seq amr parsers using triple and penman formats. despite its advantages, triple linearization can result in verbose linearization, slowing down the learning process, and may be less effective at capturing nested structures of graphs compared to penman. this study evaluates both linearization methods to train seq2seq amr parsers, exploring: (1) whether triple representation improves amr parsing; (2) which graphs benefit most from triple representation, such as those with deep structures or large size, and (3) if combining triple and penman representations enhances parsing performance. experiments involve training models respectively with triple, penman, and both formats (multitask learning). using both formats may serve as a form of data augmentation, as it effectively doubles the training data by representing one example in two linearized formats. we train and evaluate our model with english amr 3.0 @xcite data. we evaluate our model using smatch @xcite score by counting the matching triples between two graphs. we analyze results by graph depth and size to determine which types of graphs benefit from different encoding methods. ## experimental setup models are trained using the large mbart model @xcite on each linearization type. foot_0 ## results and insights global results. preserving variables consistently improves performance, contradicting the assumption that removing them aids learning by reducing data sparsity. this suggests variable removal leads to critical information loss. in addition, learning from penman encoding while performing an auxiliary triple task reduces performance, whereas the reverse improves it. this indicates penman encoding provides structural information beneficial to triple encoding but not vice versa. ## conclusion we introduced triple linearization as an alternative to penman linearization, hypothesizing that it could improve training for several reasons: (1) parent and child nodes are always located together in a triple, (2) the elimination of inverse roles may simplify training by reducing the number of relations, (3) and triples more closely resemble the underlying graph structure, while penman encoding represents a graph in a more tree-like format. contrary to our hypothesis, penman has proven to be a more effective linearization method to train a seq2seq parsing. however, the gap between the best penman model and certain triple-based models is marginal. our results show a potential to train a seq2seq amr parser that predicts a graph directly (not a treebased representation) while maintaining equivalent performance. notably, the model's output in triples more naturally aligns with amr's graph structure than penman. our code to train and evaluate the model is available on https://github. com/emvista/triple_amr_parser.git . figure 7 : amr graph for "there are too many traitors of china!". this example is drawn from amr 3.0 dataset @xcite .