A Synchronous Hyperedge Replacement Grammar based approach for AMR parsing

This paper presents a synchronous-graph-grammar-based approach for string-to-AMR parsing. We apply Markov Chain Monte Carlo (MCMC) algorithms to learn Synchronous Hyperedge Replacement Grammar (SHRG) rules from a forest that represents likely derivations consistent with a ﬁxed string-to-graph alignment. We make an analogy of string-to-AMR parsing to the task of phrase-based machine translation and come up with an efﬁcient algorithm to learn graph grammars from string-graph pairs. We pro-pose an effective approximation strategy to resolve the complexity issue of graph compositions. We also show some useful strategies to overcome existing problems in an SHRG-based parser and present pre-liminary results of a graph-grammar-based approach.


Introduction
Abstract Meaning Representation (AMR) (Banarescu et al., 2013) is a semantic formalism where the meaning of a sentence is encoded as a rooted, directed graph. Figure 1 shows an example of the edge-labeled representation of an AMR graph where the edges are labeled while the nodes are not. The label of the leaf edge going out of a node represents the concept of the node, and the label of a non-leaf edge shows the relation between the concepts of the two nodes it connects to. This formalism is based on propositional logic and neo-Davidsonian event representations (Parsons, 1990;Davidson, 1967). AMR does not encode quantifiers, tense and modality, but it jointly encodes a set of selected semantic phenomena which renders it useful in applications like question answering and semantics-based machine translation. The task of AMR graph parsing is to map natural language strings to AMR semantic graphs. Flanigan et al. (2014) propose a two-stage parsing algorithm which first maps meaningful continuous spans on the string side to concept fragments on the graph side, and then in the second stage adds additional edges to make all these fragments connected. Concept identification (Flanigan et al., 2014;Pourdamghani et al., 2014) can be considered as an important first step to relate components of the string to components in the graph. Wang et al. (2015) also present a two-stage procedure where they first use a dependency parser trained on a large corpus to generate a dependency tree for each sentence. In the second step, a transition-based algorithm is used to greedily modify the dependency tree into an AMR graph. The benefit of starting with a dependency tree instead of the original sentence is that the dependency structure is more linguistically similar to an AMR graph and provides more direct feature information within limited context.
Hyperedge replacement grammar (HRG) is a context-free rewriting formalism for generating graphs (Drewes et al., 1997). Its synchronous counterpart, SHRG, can be used for transforming a graph from/to another structured representation such as a string or tree structure. HRG has great potential for applications in natural language un-derstanding and generation, and also semanticsbased machine translation.
Given a graph as input, finding its derivation of HRG rules is NP-complete (Drewes et al., 1997). Chiang et al. (2013) describe in detail a graph recognition algorithm and present an optimization scheme which enables the parsing algorithm to run in polynomial time when the treewidth and degree of the graph are bounded. However, there is still no real system available for parsing large graphs.
An SHRG can be used for AMR graph parsing where each SHRG rule consists of a pair of a CFG rule and an HRG rule, which can generate strings and AMR graphs in parallel. Jones et al. (2012) present a Syntactic Semantic Algorithm that learns SHRG by matching minimal parse constituents to aligned graph fragments and incrementally collapses them into hyperedge nonterminals. The basic idea is to use the string-to-graph alignment and syntax information to constrain the possible HRGs.
Learning SHRG rules from fixed string-tograph alignments is a similar problem to extracting machine translation rules from fixed word alignments, where we wish to automatically learn the best granularity for the rules with which to analyze each sentence. Chung et al. (2014) present an MCMC sampling schedule to learn Hiero-style SCFG rules (Chiang, 2007) by sampling tree fragments from phrase decomposition forests, which represent all possible rules that are consistent with a set of fixed word alignments, making use of the property that each SCFG rule in the derivation is in essence the decomposition of a larger phrase pair into smaller ones.
In this paper, we make an analogy to treat fragments in the graph language as phrases in the natural language string and SHRG rules as decompositions of larger substring, graph fragment pairs into smaller ones. Graph language is different from string language in that there is no explicit order to compose the graph and there is an exponential number of possible compositions. We propose a strategy that uses the left-to-right order of the string to constrain the structure of the derivation forest and experiment with different tactics in dealing with unaligned words on the string side and unaligned edges on the graph side.
Specifically, we make the following contributions: 1. We come up an alternative SHRG-based 2. We present the novel notion of fragment decomposition forest and come up with an efficient algorithm to construct the forest from fixed string-to-graph alignment.
3. We propose an MCMC algorithm which samples a special type of SHRG rules which helps maintain the properties of AMR graphs, which should be able to generalize to learning other synchronous grammar with a CFG left side.
4. We augment the concept identification procedure of Flanigan et al. (2014) with a phraseto-graph-fragment alignment table which makes use of the dependency between concepts.
5. We discovered that an SHRG-based approach is especially sensitive to missing alignment information. We present some simple yet effective ways motivated by the AMR guideline to deal with this issue.

Hyperedge Replacement Grammar
Hyperedge replacement grammar (HRG) is a context-free rewriting formalism for graph generation (Drewes et al., 1997). HRG is like CFG in that it rewrites nonterminals independently. While CFG generates natural language strings by successively rewriting nonterminal tokens, the nonterminals in HRG are hyperedges, and each rewriting step in HRG replaces a hyperedge nonterminal with a subgraph instead of a span of a string.

Definitions
In this paper we only use edge-labeled graphs because using both node and edge labels complicates the definitions in our HRG-based approach. Figure 2 shows a series of HRG rules applied to derive the AMR graph shown in Figure 1. We start with the definition of hypergraphs. An edge-labeled, directed hypergraph is a tuple H = V, E, l, X , where V is a finite set of nodes, E ⊆ V + is a finite set of hyperedges, each of which will connect to one or more nodes in V . l : E → L defines a mapping from each hyperedge to its label from a finite set L. Each hyperedge is an atomic item with an ordered list of nodes it connects to, which are called attachment nodes. The type of a hyperedge is defined as the number of its attachment nodes. X ∈ V * defines an ordered list of distinct nodes called external nodes. The ordered external nodes specify how to fuse a hypergraph with another graph, as we will see below. In this paper, we alternately use the terms of hypergraph and graph, hyperedge and edge, and also phrase, substring and span for brevity.
An HRG is a rewriting formalism G = N, T, P, S , where N and T define two disjoint finite sets called nonterminals and terminals. S ∈ N is a special nonterminal called the start symbol. P is a finite set of productions of the form A → R, where A ∈ N and R is a hypergraph with edge labels over N ∪ T and with nonempty external nodes X R . We have the constraint that the type of the hyperedge with label A should coincide with the number of nodes in X R . In our grammar, each nonterminal has the form of Xn, where n indicates the type of the hyperedge. Our special start symbol is separately denoted as X0.
The rewriting mechanism replaces a nonterminal hyperedge with the graph fragment specified by a production's righthand side (r.h.s), attaching each external node of the r.h.s. to the corresponding attachment node of the lefthand side. Take Figure 2 as an example. Starting from our initial hypergraph with one edge labeled with the start symbol "X0", we select one edge with nontermi-  Figure 3: A series of symbol-refined SHRG rules used to derive the AMR graph for the sentence "The boy wants the girl to believe him".
nal label in our current hypergraph, and rewrite it using a rule in our HRG. The first rule rewrites the start symbol with a subgraph shown on the r.h.s.. We continue the rewriting steps until there are no more nonterminal-labeled edges. The synchronous counterpart of HRG can be used for transforming graphs from/to another form of natural language representation. Productions have the form (A → S, R , ∼), where A ∈ N and S and R are called the source and the target and at least one of them should be hypergraphs over N ∪ T . ∼ is a bijection linking nonterminals mentions in S and R. In our case, the source side is a CFG and the target side is an HRG. Given such a synchronous grammar and a string as input, we can parse the string with the CFG side and then derive the counterpart graph by deduction from the derivation. The benefit of parsing with SHRG is that the complexity is bounded by a CFG-like parsing.

SHRG-based AMR graph parsing
We write down AMR graphs as rooted, directed, edge-labeled graphs. There is exactly one leaf edge going out of each node, the label of which represents the concept of the node. We define this leaf edge as concept edge. In Figure 1, for example, the edge labeled with "boy", "want-01", "girl" or "believe-01" connects to only one node in the AMR graph and each label represents the concept of that node. AMR concepts are either English words ("boy"), PropBank framesets ("want-01"), or special keywords like special entity types, quantities, and logical conjunctions. The label of each non-leaf edge shows the relation between the AMR concepts of the two nodes it connects to.
The constraint of having exactly one concept edge for each node is not guaranteed in general SHRG. Our strategy for maintaining the AMR graph structure is to refine the edge nontermi-nal label with an extra binary flag, representing whether it will have a concept edge in the final rewriting result, for each external node. The basic intuition is to explicitly enforce the one concept edge constraint in each nonterminal so that no additional concept edge is introduced after applying each rule. The graph derived from this type of SHRG is guaranteed to have exactly one concept edge at each node. Figure 3 shows one example of our symbolrefined SHRG. For each nonterminal Xi-b 1 · · · b i , i defines the type of the nonterminal, while each b i indicates whether the i-th external node will have a concept edge in the rewriting result. 1 The second rule, for example, rewrites nonterminal X3-100 with wants on the string side and a hypergraph with three external nodes where the root has a concept edge :want-01 as the first binary flag 1 indicates, while the other two external nodes do not with the binary flag 0. This guarantees that when we integrate the r.h.s. into another graph, it will introduce the concept edge :want-01 to the first fusing position and no concept edge to the next two.
While this refinement might result in an exponential number of nonterminals with respect to the maximum type of hyperedges, we found in our experiment that most of the nonterminals do not appear in our grammar. We use a maximum edge type of 5, which also results in a relatively small nonterminal set.

Sampling SHRG from forests
The fragment decomposition forest provides a compact representation of all possible SHRG rules that are consistent with a fixed string-to-graph alignment. Each SHRG rule in the derivation is in essence the decomposition of larger phrase, graph fragment pairs on the left hand side (l.h.s.) into smaller ones on the r.h.s. and is encoded in a tree fragment in the forest. Our goal is to learn an SHRG from this forest. We first build a forest representation of possible derivations and then use an MCMC algorithm to sample tree fragments from this forest representing each rule in the derivation.

Fragment Decomposition Forest
We first proceed to define the fragment decomposition forest. The fragment decomposition forest is a variation of the phrase decomposition forest 1 X0-1 is different as X0 is the start symbol of type one and should always have a concept edge at the root defined by Chung et al. (2014) where the target side is a graph instead of a string.
A fragment f is a hypergraph with external nodes X f . A stringto-graph alignment h : P → F defines the mapping from spans in the sentence to fragments in the graph. Our smallest phrase-fragment pairs are the string-to-graph alignments extracted using heuristic rules from Flanigan et al. (2014). The figure above shows an example of the alignments for the sentence "The boy wants the girl to believe him". The symbol ∅ represents that the word is not aligned to any concept in the AMR graph and this word is called an unaligned word. After this alignment, there are also left-over edges that are not aligned from any substrings, which are called unaligned edges.
Given an aligned string, AMR graph pair, a phrase-fragment pair n is a pair ([i, j], f ) which defines a pair of a phrase [i, j] and a fragment f such that words in positions [i, j] are only aligned to concepts in the fragment f and vice versa (with unaligned words and edges omitted). A fragment forest H = V, E is a hypergraph made of a set of hypernodes V and hyperedges E. Each node n = ([i, j], f ) is tight on the string side similar to the definition by Koehn et al. (2003), i.e., n contains no unaligned words at its boundaries. Note here we do not have the constraint that f should be connected or single rooted, but we will deal with these constraints separately in the sampling procedure.
We define two phrases [i 1 , j 1 ], [i 2 , j 2 ] to be adjacent if word indices {j 1 , j 1 + 1, . . . , i 2 − 1} are all unaligned. We also define two fragments And f 1 and f 2 are adjacent if they are disjoint and f = V 1 ∪ V 2 , E 1 ∪ E 2 is connected. We also define the compose operation of two nodes: it takes two nodes n 1 = ([i 1 , j 1 ], f 1 ) and n 2 = ([i 2 , j 2 ], f 2 ) (j 1 ≤ i 2 ) as input, and computes f = V 1 ∪ V 2 , E 1 ∪ E 2 , the output is a composed node n = ([i 1 , j 2 ], f ). We say n 1 and n 2 are immediately adjacent if f is connected and single-rooted.
We keep composing larger phrase-fragment  Figure 4: The fragment decomposition forest for the (sentence, AMR graph) pair for "The boy wants the girl to believe him" pairs (each one kept in a node of the forest) from smaller ones until we reach the root of the forest whose phrase side is the whole sentence and the fragment side is the complete AMR graph. We define fragment decomposition forest to be made of all possible phrase-fragments pairs that can be decomposed from the sentence AMR graph pair. The fragment decomposition forest has the important property that any SHRG rule consistent with the string-to-graph alignment corresponds to a continuous tree fragment of a complete tree found in the forest.
While we can compose larger phrases from smaller ones from left to right, there is no explicit order of composing the graph fragments. Also, the number of possible graph fragments is highly exponential as we need to make a binary decision to decide each boundary node of the fragment and also choose the edges going out of each boundary node of the fragment, unlike the polynomial numbers of phrases for fixed string alignment.
Our bottom-up construction procedure starts from the smallest phrase-fragment pairs. We first index these smallest phrase-fragment pairs ([i k , j k ], f k ), k = 1, 2, . . . , n based on ascending order of their start positions on the string side, i.e., j k ≤ i k+1 for k = 1, 2, . . . , n − 1. Even with this left-to-right order constraint from the string side, the complexity of building the forest is still exponential due to the possible choices in attaching graphs edges that are not aligned to the string. Our strategy is to deterministically attach each unaligned relation edge to one of the identified concept fragments it connects to. We attach ARGs and ops to its head node and each other types of un-Algorithm 1 A CYK-like algorithm for building a fragment decomposition forest 1: For each smallest phrase-fragment pairs ([i k , j k ], f k ), k = 1, 2, . . . , n, attach unaligned edges to fragment f k , denoting the result as f k . Build a node for ([i k , j k ], f k ) and add it to chart item c[k][k + 1]. 2: Extract all the remaining unaligned fragments, build a special unaligned node for each of them and add it to unaligned node set unaligned nodes 3: Keep composing unaligned nodes with nodes in different chart items if they are immediate adjacent and add it to the same chart item 4: for span from 2 to n do 5: for i from 1 to n-span+1 do 6: j = i + span 7: for k from i + 1 to j − 1 do 8: for n1  aligned relations to its tail node. 2 Algorithm 1 shows our CYK-like forest construction algorithm. We maintain the length 1 chart items according to the order of each smallest phrase-fragment pair instead of its position in the string. 3 In line 1, we first attach unaligned edges to the smallest phrase-fragment pairs as stated before. After this procedure, we build a node for the k-th phrase-fragment (with unaligned edges added) pair and add it to chart item c[k][k + 1]. Note here that we still have remaining unaligned edges; in line 2 we attach all unaligned edges going out from the same node as a single fragment and build a special unaligned node with empty phrase side and add it to unaligned nodes set. In line 3, we try to compose each unaligned node with one of the nodes in the length 1 chart items c[k][k + 1]. If they are immediately adjacent, we add the composed node to c[k][k + 1]. The algorithm then composes smaller phrase-fragment pairs into larger ones (line 4). When we have composed two nodes n 1 , n 2 , we need to keep track of this incoming edge. We have the constraint in our grammar that the r.h.s. hypergraph of each rule should be connected and single rooted. 4 Lines 13 to 14 enforce this constraint by marking this node with a nosample cut flag, which we will use in the MCMC sampling stage. The insert node function will check if the node already exists in the chart item. If it already exists, then we only update the incoming edges for that node. Otherwise we will add it to the chart item.
For some sentence-AMR pairs where there are too many nodes with unaligned edges going out, considering all possible compositions would result in huge complexity overhead. One solution we have adopted is to disallow disconnected graph fragments and do not add them to the chart items (Line 15). In practice, this pruning procedure does not affect much of the final performance in our current setting. Figure 4 shows the procedure of building the fragment decomposition forest for the sentence "The boy wants the girl to believe him".

MCMC sampling
Sampling methods have been used to learn Tree Substitution Grammar (TSG) rules from derivation trees (Cohn et al., 2009;Post and Gildea, 2009) for TSG learning. The basic intuition is to automatically learn the best granularity for the rules with which to analyze our data. Our problem, however, is different in that we need to sample rules from a compact forest representation. We need to sample one tree from the forest, and then sample one derivation from this tree structure, where each tree fragment represents one rule in the derivation. Sampling tree fragments from forests is described in detail in Chung et al. (2014) and Peng and Gildea (2014).
We formulate the rule sampling procedure with two types of variables: an edge variable e n representing which incoming hyperedge is chosen at a given node n in the forest (allowing us to sample one tree from a forest) and a cut variable z n representing whether node n in forest is a boundary between two SHRG rules or is internal to an SHRG rule (allowing us to sample rules from a tree). Figure 5 shows one sampled derivation from the forest. We have sampled one tree from the forest using the edge variables. We also have a 0-1 variable at each node in this tree where 0 repre- 4 We should be able to get rid of both constraints as we are parsing on the string side. sents the current node is internal to an SHRG rule, while 1 represents the current node is the boundary of two SHRG rules. Let all the edge variables form the random vector Y and all the cut variables form the random vector Z. Given an assignment y to the edge variables and assignment z to the cut variables, our desired distribution is proportional to the product of weights of the rules specified by the assignment: where τ (y, z) is the set of rules identified by the assignment and w(r) is the weight for each individual rule. We use a generative model based on a Dirichlet Process (DP) defined over composed rules. We draw a distribution G over rules from a DP, and then rules from G.
We define two rules to have the same rule type if they have the same string and hypergraph representation (including order of external nodes) on the r.h.s..For the base distribution P 0 , we use a uniform distribution where all rules of the same size have equal probability. By marginalizing out G we get a simple posterior distribution over rules which can be derived using the Chinese Restaurant Process (CRP). We define a table of counts N = {N C } C∈I which memorizes different categories of counts in the previous assignments, where I is an index set for different categories of counts. Each N C is a vector of counts for category C. We have the following probability over rule r given the previous count table N : here in the case of DP, I = {R}, where R is the index for the category of rule counts. We use the top-down sampling algorithm of Chung et al. (2014) which samples cut and edge variables from top down and one at a time. For each node n, we denote the composed rule type that we get when we set the cut of node n to 0 as r 1 and the two split rule types that we get when we set the cut to 1 as r 2 , r 3 . We sample the cut value z i of the current node according to the posterior probability: where the posterior probability P (r i |N ) is according to a DP, and N, N are tables of counts. In the case of DP, N, N differ only in the rule counts of r 2 , where N R (r 2 ) = N R (r 2 ) + 1.
As for edge variables e i , we refer to the set of composed rules turned on below n including the composed rule fragments having n as an internal or root node as {r 1 , . . . , r m }. We have the following posterior probability over the edge variable e i : where deg(v) is the number of incoming edges for node v, in(n) is the set of nodes in all subtrees under n, and τ (e) is the tree specified when we set e i = e. N 0 to N m are tables of counts where After we have sampled one SHRG derivation from the forest, we still need to keep track of the place where each nonterminal edge attaches. As we have maintained the graph fragment it represents in each node of the forest, we can retrieve the attachment nodes of each hyperedge in the r.h.s. by tracing at which graph nodes two fragments fuse with each other. We perform this rule extraction procedure from top-down and maintain the order of attachment nodes of each r.h.s. nonterminal edge. When we further rewrite a nonterminal edge, we need to make sure that it keeps the order of the attachment nodes in its parent rule.
As for the unaligned words, we just insert all the omitted unaligned words in the composition procedure. We also add additional rules including the surrounding 2 unaligned words context to make sure there are terminals on the string side.

Phrase-to-Graph-Fragment Alignment Extraction
Aside from the rules sampled using the MCMC algorithm, we also extract a phrase-to-graphfragment alignment table from the fragment decomposition forest. This step can be considered as a mapping of larger phrases made of multiple identified spans (plus unaligned words) to a larger fragments made of multiple concept fragments (plus the way they connect using unaligned edges). Our extraction happens along with the forest construction procedure. In line 1 of Algorithm 1 we extract one rule for each smallest phrasefragment pairs before and after the unaligned edges are attached. We also extract one rule for each newly constructed node after line 11 if the fragment side of the node is single-rooted. 5 We do not extract rules after line 2 because it usually introduces additional noise of meaningful concepts which are unrecognized in the concepts identification stage.

Concept identification
During the decoding stage, first we need to identify meaningful spans in the sentence and map them to graph fragments on the graph side. Then we use SHRG rules to parse each sentence from bottom up and left to right, which is similar to constituent parsing. The recall of the concept identification stage from Flanigan et al. (2014) is 0.79, which means 21% of the meaningful concepts are already lost at the beginning of the next stage.
Our strategy is to use lemma and POS tags information after the concept identification stage, we use it to recall some meaningful concepts. We find that, except for some special function words, most nouns, verbs and, adjectives should be aligned. We use the lemma information to retrieve unaligned words whose morphological form does not appear in our training data. We also use POS tag information to deal with nouns and quantities. Motivated by the fact that AMR makes extensive use of PropBank framesets, we look up the argument structure of the verbs from the Prop-Bank. Although the complicated abstraction of AMR makes it hard to get the correct concept for each word, the more complete structure can reduce the propagation of errors along the derivation tree.

AMR graph parsing
We use Earley algorithm with cube-pruning (Chiang, 2007) for the string-to-AMR parsing. For each synchronous rule with N nonterminals on its l.h.s., we build an N + 1 dimensional cube and generate top K candidates. Out of all the hypotheses generated by all satisfied rules within each span (i, j),we keep at most K candidates for this span. Our glue rules will create a pseudo R/ROOT concept and use ARGs relations to connect disconnected components to make a connected graph.
We use the following local features: 6. GlueCount: one for glue rules.
As our forest structure is highly binarized, it is hard to capture the :opn structure when n is large because we limit the number of external nodes to 5. The most common :op structure in the AMR annotation is the coordinate structure of items separated by ";" or separated by "," along with and.
We add the following two rules: where the HRG side is a :a/and coordinate structure of X1-1s connected with relation :ops.

Experiments
We use the same newswire section of LDC2013E117 as Flanigan et al. (2014), which consists of 3955 training sentences, 2132 dev sentences and 2132 test sentences. We also use the string-to-graph alignment from Flanigan et al. (2014) to construct the fragment decomposition forest and to extract the phrase-to-fragment table.
In the fragment decomposition forest construction procedure, we have experimented with different ways of dealing with the unaligned edges. First we have tried to directly use the alignment, and group all unaligned edges going out from the same node as an unaligned fragment. Using this constraint would take a few hours or longer for some sentences. The reason for this is because the many number of unaligned edges can connect to each branch of the aligned or unaligned fragments below it. And there is no explicit order of composition with each branch. Another constraint we have tried is to attach all unaligned edges to the head node concept. The problem with this constraint is that it is very hard to generalize and introduces a lot of additional redundant relation edges.
As for sampling, we initialize all cut variables in the forest as 1 (except for nodes that are marked as nosample cut, which indicates we initialize it with 0 and keep it fixed) and uniformly sample an incoming edge for each node. We evaluate the performance of our SHRG-based parser using Smatch v1.0 , which evaluates the precision, recall and F 1 of the concepts and relations all together. Table 1 shows the dev results of our sampled grammar using different lexical rules that maps substrings to graph fragments. Concept id only is the result of using the concepts identified by Flanigan et al. (2014). From second line, we replace the concept identification result with the lexical rules we have extracted from the training data (except for named entities and time expressions). +MCMC shows the result using additional alignments identified using our sampling approach. We can see that using the phrase to graph fragment alignment learned from our training data can significantly improve the smatch. We have also tried extracting all phrase-to-fragment  alignments of length 6 on the string side from our constructed forest. We can see that using this alignment table further improves the smatch score. This is because the larger phrase-fragment pairs can make better use of the dependency information between continuous concepts. The improvement is not much in comparison with MCMC, this is perhaps MCMC can also learn some meaning blocks that frequently appear together. As the dataset is relatively small, so there are a lot of meaningful concepts that are not aligned. We use lemma as a backoff strategy to find the alignment for the unaligned words. We have also used the POS tag information to retrieve some unaligned nouns and a PropBank dictionary to retrieve the argument structure of the first sense of the verbs. +All shows the result after using lemma, POS tag and PropBank information, we can see that fixing the alignment can improve the recall, but the precision does not change much. Table 2 shows our result on test data. JAMR is the baseline result from Flanigan et al. (2014). Wang et al. (2015) shows the current state-ofart for string-to-AMR parsing. Without the dependency parse information and complex global features, our SHRG-based approach can already achieve competitive results in comparison with these two algorithms.

Discussion
In comparison to the spanning tree algorithm of Flanigan et al. (2014), an SHRG-based approach is more sensitive to the alignment. If a lot of the meaningful concepts are not aligned, then the lost information would break down the structure of our grammar. Using more data would definitely help ease this issue. Building overlapping alignments for the training data with more concepts alignment would also be helpful.
Another thing to note is that Flanigan et al. (2014) have used path information of dependency arc labels and part of speech tags. Using these global information can help the predication of the relation edge labels. One interesting way to include such kind of path information is to add a graph language model into our CFG decoder, which should also help improve the performance.
All the weights of the local features mentioned in Section 4.2 are tuned by hand. We have tried tuning with MERT (Och, 2003), but the computation of smatch score for the k-best list has become a major overhead. This issue might come from the NP-Completeness of the problem smatch tries to evaluate, unlike the simple counting of N-grams in BLEU (Papineni et al., 2001). Parallelization might be a consideration for tuning smatch score with MERT.

Conclusion
We presented an MCMC sampling schedule for learning SHRG rules from a fragment decomposition forest constructed from a fixed string-to-AMR-graph alignment. While the complexity of building a fragment decomposition forest is highly exponential, we have come up with an effective constraint from the string side that enables an efficient construction algorithm. We have also evaluated our sampled SHRG on a string-to-AMR graph parsing task and achieved some reasonable result without using a dependency parse. Interesting future work might include adding language model on graph structure and also learning SHRG from overlapping alignments.