A Transition-Based Directed Acyclic Graph Parser for UCCA

TL;DR

This paper introduces the first parser for UCCA, a cross-linguistic semantic framework, capable of handling complex DAG structures, discontinuities, and non-terminal nodes, advancing semantic parsing technology.

Contribution

It presents a novel transition-based parser with a unique transition set and bidirectional LSTM features, supporting complex DAG structures in semantic parsing.

Findings

Successfully parses UCCA structures with reentrancy and discontinuities

Handles non-terminal nodes representing complex semantic units

Offers a parser architecture applicable to other semantic DAGs

Abstract

We present the first parser for UCCA, a cross-linguistically applicable framework for semantic representation, which builds on extensive typological work and supports rapid annotation. UCCA poses a challenge for existing parsing techniques, as it exhibits reentrancy (resulting in DAG structures), discontinuous structures and non-terminal nodes corresponding to complex semantic units. To our knowledge, the conjunction of these formal properties is not supported by any existing parser. Our transition-based parser, which uses a novel transition set and features based on bidirectional LSTMs, has value not just for UCCA parsing: its ability to handle more general graph structures can inform the development of parsers for other semantic DAG structures, and in languages that frequently use discontinuous structures.

Tables

Table 1. Table 1: Statistics of the Wiki and 20K Leagues UCCA corpora. All counts exclude the root node, implicit nodes, and linkage nodes and edges.

	Wiki			20K
	Train	Dev	Test	Leagues
# passages	300	34	33	154
# sentences	4268	454	503	506
# nodes	298,993	33,704	35,718	29,315
% terminal	42.96	43.54	42.87	42.09
% non-term.	58.33	57.60	58.35	60.01
% discont.	0.54	0.53	0.44	0.81
% reentrant	2.38	1.88	2.15	2.03
# edges	287,914	32,460	34,336	27,749
% primary	98.25	98.75	98.74	97.73
% remote	1.75	1.25	1.26	2.27
Average per non-terminal node
# children	1.67	1.68	1.66	1.61

Table 2. Table 2: Experimental results, in percents, on the Wiki test set (left) and the 20K Leagues set (right). Columns correspond to labeled precision, recall and F-score, for both primary and remote edges. F-score upper bounds are reported for the conversions. For the tree approximation experiments, only primary edges scores are reported, as they are unable to predict remote edges. TUPA BiLSTM obtains the highest F-scores in all metrics, surpassing the bilexical parsers, tree parsers and other classifiers.

	Wiki (in-domain)						20K Leagues (out-of-domain)
	Primary			Remote			Primary			Remote
	LP	LR	LF	LP	LR	LF	LP	LR	LF	LP	LR	LF
TUPASparse	64.5	63.7	64.1	19.8	13.4	16	59.6	59.9	59.8	22.2	7.7	11.5
TUPAMLP	65.2	64.6	64.9	23.7	13.2	16.9	62.3	62.6	62.5	20.9	6.3	9.7
TUPABiLSTM	74.4	72.7	73.5	47.4	51.6	49.4	68.7	68.5	68.6	38.6	18.8	25.3
Bilexical Approximation (Dependency DAG Parsers)
Upper Bound			91			58.3			91.3			43.4
DAGParser	61.8	55.8	58.6	9.5	0.5	1	56.4	50.6	53.4	–	0	0
TurboParser	57.7	46	51.2	77.8	1.8	3.7	50.3	37.7	43.1	100	0.4	0.8
Tree Approximation (Constituency Tree Parser)
Upper Bound			100			–			100			–
uparse	60.9	61.2	61.1	–	–	–	52.7	52.8	52.8	–	–	–
Bilexical Tree Approximation (Dependency Tree Parsers)
Upper Bound			91			–			91.3			–
MaltParser	62.8	57.7	60.2	–	–	–	57.8	53	55.3	–	–	–
LSTM Parser	73.2	66.9	69.9	–	–	–	66.1	61.1	63.5	–	–	–

Table 3. Table 3: Statistics of linkage and implicit nodes in the Wiki and 20K Leagues UCCA corpora. Cf. Table  1 .

	Wiki			20K
	Train	Dev	Test	Leagues
nodes
# implicit	899	122	77	241
# linkage	2956	263	359	376
edges
# linkage	9276	803	1094	957

Table 4. Table 4: Hyperparameters used for the different classifiers.

	Sparse	MLP	BiLSTM
Embedding dimensions
external word		100	100
word		200	200
POS tag		20	20
syntactic dep.		10	10
edge label		20	20
punctuation		1	1
gap		3	3
action		3	3
Other parameters
training epochs	19	28	59
MinUpdate	5
initial learning rate	1	1	1
learning rate decay	0.1	1	1
MLP #layers		2	2
MLP layer dim.		100	50
LSTM #layers			2
LSTM layer dim.			500
word dropout		0.2	0.2
dropout		0.4	0.4
weight decay		${10}^{-5}$	${10}^{-5}$
mini-batch size		100	100

Equations

$$\left\{\begin{array}[]{l}x\not\in w_{1:n},\\ y\neq\mathrm{root},\\ y\not\leadsto_{G}x\end{array}\right.$$

$$\begin{gathered} M(G_p,G_g)= \\ \left\{(e_1,e_2)\in E_p\times E_g|y(e_1)=y(e_2)\wedge {\ell }_p(e_1)={\ell }_g(e_2)\right\} \end{gathered}$$

$$N(t)=\{(u,v)\in E|t=h^{\ast }(v)\wedge t\ne h^{\ast }(u)\}$$

Full text

1 Introduction

Universal Conceptual Cognitive Annotation (UCCA, Abend and Rappoport, 2013) is a cross-linguistically applicable semantic representation scheme, building on the established Basic Linguistic Theory typological framework Dixon (2010a, b, 2012), and Cognitive Linguistics literature Croft and Cruse (2004). It has demonstrated applicability to multiple languages, including English, French, German and Czech, support for rapid annotation by non-experts (assisted by an accessible annotation interface Abend et al. (2017)), and stability under translation Sulem et al. (2015). It has also proven useful for machine translation evaluation Birch et al. (2016). UCCA differs from syntactic schemes in terms of content and formal structure. It exhibits reentrancy, discontinuous nodes and non-terminals, which no single existing parser supports. Lacking a parser, UCCA’s applicability has been so far limited, a gap this work addresses.

We present the first UCCA parser, TUPA (Transition-based UCCA Parser), building on recent advances in discontinuous constituency and dependency graph parsing, and further introducing novel transitions and features for UCCA. Transition-based techniques are a natural starting point for UCCA parsing, given the conceptual similarity of UCCA’s distinctions, centered around predicate-argument structures, to distinctions expressed by dependency schemes, and the achievements of transition-based methods in dependency parsing Dyer et al. (2015); Andor et al. (2016); Kiperwasser and Goldberg (2016). We are further motivated by the strength of transition-based methods in related tasks, including dependency graph parsing Sagae and Tsujii (2008); Ribeyre et al. (2014); Tokgöz and Eryiğit (2015), constituency parsing Sagae and Lavie (2005); Zhang and Clark (2009); Zhu et al. (2013); Maier (2015); Maier and Lichte (2016), AMR parsing Wang et al. (2015a, b, 2016); Misra and Artzi (2016); Goodman et al. (2016); Zhou et al. (2016); Damonte et al. (2017) and CCG parsing Zhang and Clark (2011); Ambati et al. (2015, 2016).

We evaluate TUPA on the English UCCA corpora, including in-domain and out-of-domain settings. To assess the ability of existing parsers to tackle the task, we develop a conversion procedure from UCCA to bilexical graphs and trees. Results show superior performance for TUPA, demonstrating the effectiveness of the presented approach.111All parsing and conversion code, as well as trained parser models, are available at https://github.com/danielhers/tupa.

The rest of the paper is structured as follows: Section 2 describes UCCA in more detail. Section 3 introduces TUPA. Section 4 discusses the data and experimental setup. Section 5 presents the experimental results. Section 6 summarizes related work, and Section 7 concludes the paper.

2 The UCCA Scheme

UCCA graphs are labeled, directed acyclic graphs (DAGs), whose leaves correspond to the tokens of the text. A node (or unit) corresponds to a terminal or to several terminals (not necessarily contiguous) viewed as a single entity according to semantic or cognitive considerations. Edges bear a category, indicating the role of the sub-unit in the parent relation. Figure 1 presents a few examples.

UCCA is a multi-layered representation, where each layer corresponds to a “module” of semantic distinctions. UCCA’s foundational layer, targeted in this paper, covers the predicate-argument structure evoked by predicates of all grammatical categories (verbal, nominal, adjectival and others), the inter-relations between them, and other major linguistic phenomena such as coordination and multi-word expressions. The layer’s basic notion is the scene, describing a state, action, movement or some other relation that evolves in time. Each scene contains one main relation (marked as either a Process or a State), as well as one or more Participants. For example, the sentence “After graduation, John moved to Paris” (Figure 1(a)) contains two scenes, whose main relations are “graduation” and “moved”. “John” is a Participant in both scenes, while “Paris” only in the latter. Further categories account for inter-scene relations and the internal structure of complex arguments and relations (e.g. coordination, multi-word expressions and modification).

One incoming edge for each non-root node is marked as primary, and the rest (mostly used for implicit relations and arguments) as remote edges, a distinction made by the annotator. The primary edges thus form a tree structure, whereas the remote edges enable reentrancy, forming a DAG.

While parsing technology in general, and transition-based parsing in particular, is well-established for syntactic parsing, UCCA has several distinct properties that distinguish it from syntactic representations, mostly UCCA’s tendency to abstract away from syntactic detail that do not affect argument structure. For instance, consider the following examples where the concept of a scene has a different rationale from the syntactic concept of a clause. First, non-verbal predicates in UCCA are represented like verbal ones, such as when they appear in copula clauses or noun phrases. Indeed, in Figure 1(a), “graduation” and “moved” are considered separate events, despite appearing in the same clause. Second, in the same example, “John” is marked as a (remote) Participant in the graduation scene, despite not being overtly marked. Third, consider the possessive construction in Figure 1(c). While in UCCA “trip” evokes a scene in which “John and Mary” is a Participant, a syntactic scheme would analyze this phrase similarly to “John and Mary’s shoes”.

These examples demonstrate that a UCCA parser, and more generally semantic parsers, face an additional level of ambiguity compared to their syntactic counterparts (e.g., “after graduation” is formally very similar to “after 2pm”, which does not evoke a scene). Section 6 discusses UCCA in the context of other semantic schemes, such as AMR Banarescu et al. (2013).

Alongside recent progress in dependency parsing into projective trees, there is increasing interest in parsing into representations with more general structural properties (see Section 6). One such property is reentrancy, namely the sharing of semantic units between predicates. For instance, in Figure 1(a), “John” is an argument of both “graduation” and “moved”, yielding a DAG rather than a tree. A second property is discontinuity, as in Figure 1(b), where “gave up” forms a discontinuous semantic unit. Discontinuities are pervasive, e.g., with multi-word expressions Schneider et al. (2014). Finally, unlike most dependency schemes, UCCA uses non-terminal nodes to represent units comprising more than one word. The use of non-terminal nodes is motivated by constructions with no clear head, including coordination structures (e.g., “John and Mary” in Figure 1(c)), some multi-word expressions (e.g., “The Haves and the Have Nots”), and prepositional phrases (either the preposition or the head noun can serve as the constituent’s head). To our knowledge, no existing parser supports all structural properties required for UCCA parsing.

3 Transition-based UCCA Parsing

We now turn to presenting TUPA. Building on previous work on parsing reentrancies, discontinuities and non-terminal nodes, we define an extended set of transitions and features that supports the conjunction of these properties.

Transition-based parsers Nivre (2003) scan the text from start to end, and create the parse incrementally by applying a transition at each step to the parser’s state, defined using three data structures: a buffer $B$ of tokens and nodes to be processed, a stack $S$ of nodes currently being processed, and a graph $G=(V,E,\ell)$ of constructed nodes and edges, where $V$ is the set of nodes, $E$ is the set of edges, and $\ell:E\to L$ is the label function, $L$ being the set of possible labels. Some states are marked as terminal, meaning that $G$ is the final output. A classifier is used at each step to select the next transition based on features encoding the parser’s current state. During training, an oracle creates training instances for the classifier, based on gold-standard annotations.

Transition Set.

Given a sequence of tokens $w_{1},\ldots,w_{n}$, we predict a UCCA graph $G$ over the sequence. Parsing starts with a single node on the stack (an artificial root node), and the input tokens in the buffer. Figure 2 shows the transition set.

In addition to the standard Shift and Reduce operations, we follow previous work in transition-based constituency parsing Sagae and Lavie (2005), adding the Node transition for creating new non-terminal nodes. For every $X\in L$, NodeX creates a new node on the buffer as a parent of the first element on the stack, with an $X$-labeled edge. Left-EdgeX and Right-EdgeX create a new primary $X$-labeled edge between the first two elements on the stack, where the parent is the left or the right node, respectively. As a UCCA node may only have one incoming primary edge, Edge transitions are disallowed if the child node already has an incoming primary edge. Left-RemoteX and Right-RemoteX do not have this restriction, and the created edge is additionally marked as remote. We distinguish between these two pairs of transitions to allow the parser to create remote edges without the possibility of producing invalid graphs. To support the prediction of multiple parents, node and edge transitions leave the stack unchanged, as in other work on transition-based dependency graph parsing Sagae and Tsujii (2008); Ribeyre et al. (2014); Tokgöz and Eryiğit (2015). Reduce pops the stack, to allow removing a node once all its edges have been created. To handle discontinuous nodes, Swap pops the second node on the stack and adds it to the top of the buffer, as with the similarly named transition in previous work Nivre (2009); Maier (2015). Finally, Finish pops the root node and marks the state as terminal.

Classifier.

The choice of classifier and feature representation has been shown to play an important role in transition-based parsing Chen and Manning (2014); Andor et al. (2016); Kiperwasser and Goldberg (2016). To investigate the impact of the type of transition classifier in UCCA parsing, we experiment with three different models.

Starting with a simple and common choice (e.g., Maier and Lichte, 2016), TUPASparse uses a linear classifier with sparse features, trained with the averaged structured perceptron algorithm Collins and Roark (2004) and MinUpdate Goldberg and Elhadad (2011): each feature requires a minimum number of updates in training to be included in the model.222We also experimented with a linear model using dense embedding features, trained with the averaged structured perceptron algorithm. It performed worse than the sparse perceptron model and was hence discarded. 2. 2.

Changing the model to a feedforward neural network with dense embedding features, TUPAMLP (“multi-layer perceptron”), uses an architecture similar to that of Chen and Manning (2014), but with two rectified linear layers instead of one layer with cube activation. The embeddings and classifier are trained jointly. 3. 3.

Finally, TUPABiLSTM uses a bidirectional LSTM for feature representation, on top of the dense embedding features, an architecture similar to Kiperwasser and Goldberg (2016). The BiLSTM runs on the input tokens in forward and backward directions, yielding a vector representation that is then concatenated with dense features representing the parser state (e.g., existing edge labels and previous parser actions; see below). This representation is then fed into a feedforward network similar to TUPAMLP. The feedforward layers, BiLSTM and embeddings are all trained jointly.

For all classifiers, inference is performed greedily, i.e., without beam search. Hyperparameters are tuned on the development set (see Section 4).

Features.

TUPASparse uses binary indicator features representing the words, POS tags, syntactic dependency labels and existing edge labels related to the top four stack elements and the next three buffer elements, in addition to their children and grandchildren in the graph. We also use bi- and trigram features based on these values Zhang and Clark (2009); Zhu et al. (2013), features related to discontinuous nodes (Maier, 2015, including separating punctuation and gap type), features representing existing edges and the number of parents and children, as well as the past actions taken by the parser. In addition, we use use a novel, UCCA-specific feature: number of remote children.333See Appendix A for a full list of used feature templates.

For TUPAMLP and TUPABiLSTM, we replace all indicator features by a concatenation of the vector embeddings of all represented elements: words, POS tags, syntactic dependency labels, edge labels, punctuation, gap type and parser actions. These embeddings are initialized randomly. We additionally use external word embeddings initialized with pre-trained word2vec vectors Mikolov et al. (2013),444https://goo.gl/6ovEhC updated during training. In addition to dropout between NN layers, we apply word dropout Kiperwasser and Goldberg (2016): with a certain probability, the embedding for a word is replaced with a zero vector. We do not apply word dropout to the external word embeddings.

Finally, for all classifiers we add a novel real-valued feature to the input vector, ratio, corresponding to the ratio between the number of terminals to number of nodes in the graph $G$. This feature serves as a regularizer for the creation of new nodes, and should be beneficial for other transition-based constituency parsers too.

Training.

For training the transition classifiers, we use a dynamic oracle Goldberg and Nivre (2012), i.e., an oracle that outputs a set of optimal transitions: when applied to the current parser state, the gold standard graph is reachable from the resulting state. For example, the oracle would predict a Node transition if the stack has on its top a parent in the gold graph that has not been created, but would predict a Right-Edge transition if the second stack element is a parent of the first element according to the gold graph and the edge between them has not been created. The transition predicted by the classifier is deemed correct and is applied to the parser state to reach the subsequent state, if the transition is included in the set of optimal transitions. Otherwise, a random optimal transition is applied, and for the perceptron-based parser, the classifier’s weights are updated according to the perceptron update rule.

POS tags and syntactic dependency labels are extracted using spaCy Honnibal and Johnson (2015).555https://spacy.io We use the categorical cross-entropy objective function and optimize the NN classifiers with the Adam optimizer Kingma and Ba (2014).

4 Experimental Setup

Data.

We conduct our experiments on the UCCA Wikipedia corpus (henceforth, Wiki), and use the English part of the UCCA Twenty Thousand Leagues Under the Sea English-French parallel corpus (henceforth, 20K Leagues) as out-of-domain data.666http://cs.huji.ac.il/~oabend/ucca.html Table 1 presents some statistics for the two corpora. We use passages of indices up to 676 of the Wiki corpus as our training set, passages 688–808 as development set, and passages 942–1028 as in-domain test set. While UCCA edges can cross sentence boundaries, we adhere to the common practice in semantic parsing and train our parsers on individual sentences, discarding inter-relations between them (0.18% of the edges). We also discard linkage nodes and edges (as they often express inter-sentence relations and are thus mostly redundant when applied at the sentence level) as well as implicit nodes.777Appendix B further discusses linkage and implicit units. In the out-of-domain experiments, we apply the same parsers (trained on the Wiki training set) to the 20K Leagues corpus without parameter re-tuning.

Implementation.

We use the DyNet package Neubig et al. (2017) for implementing the NN classifiers. Unless otherwise noted, we use the default values provided by the package. See Appendix C for the hyperparameter values we found by tuning on the development set.

Evaluation.

We define a simple measure for comparing UCCA structures $G_{p}=(V_{p},E_{p},\ell_{p})$ and $G_{g}=(V_{g},E_{g},\ell_{g})$, the predicted and gold-standard graphs, respectively, over the same sequence of terminals $W=\{w_{1},\ldots,w_{n}\}$. For an edge $e=(u,v)$ in either graph, $u$ being the parent and $v$ the child, its yield $y(e)\subseteq W$ is the set of terminals in $W$ that are descendants of $v$. Define the set of mutual edges between $G_{p}$ and $G_{g}$:

[TABLE]

Labeled precision and recall are defined by dividing $|M(G_{p},G_{g})|$ by $|E_{p}|$ and $|E_{g}|$, respectively, and F-score by taking their harmonic mean. We report two variants of this measure: one where we consider only primary edges, and another for remote edges (see Section 2). Performance on remote edges is of pivotal importance in this investigation, which focuses on extending the class of graphs supported by statistical parsers.

We note that the measure collapses to the standard PARSEVAL constituency evaluation measure if $G_{p}$ and $G_{g}$ are trees. Punctuation is excluded from the evaluation, but not from the datasets.

Comparison to bilexical graph parsers.

As no direct comparison with existing parsers is possible, we compare TUPA to bilexical dependency graph parsers, which support reentrancy and discontinuity but not non-terminal nodes.

To facilitate the comparison, we convert our training set into bilexical graphs (see examples in Figure 4), train each of the parsers, and evaluate them by applying them to the test set and then reconstructing UCCA graphs, which are compared with the gold standard. The conversion to bilexical graphs is done by heuristically selecting a head terminal for each non-terminal node, and attaching all terminal descendents to the head terminal. In the inverse conversion, we traverse the bilexical graph in topological order, creating non-terminal parents for all terminals, and attaching them to the previously-created non-terminals corresponding to the bilexical heads.888See Appendix D for a detailed description of the conversion procedures.

In Section 5 we report the upper bounds on the achievable scores due to the error resulting from the removal of non-terminal nodes.

Comparison to tree parsers.

For completeness, and as parsing technology is considerably more mature for tree (rather than graph) parsing, we also perform a tree approximation experiment, converting UCCA to (bilexical) trees and evaluating constituency and dependency tree parsers on them (see examples in Figure 5). Our approach is similar to the tree approximation approach used for dependency graph parsing Agić et al. (2015); Fernández-González and Martins (2015), where dependency graphs were converted into dependency trees and then parsed by dependency tree parsers. In our setting, the conversion to trees consists simply of removing remote edges from the graph, and then to bilexical trees by applying the same procedure as for bilexical graphs.

Baseline parsers.

We evaluate two bilexical graph semantic dependency parsers: DAGParser Ribeyre et al. (2014), the leading transition-based parser in SemEval 2014 Oepen et al. (2014) and TurboParser Almeida and Martins (2015), a graph-based parser from SemEval 2015 Oepen et al. (2015); uparse Maier and Lichte (2016), a transition-based constituency parser supporting discontinuous constituents; and two bilexical tree parsers: MaltParser Nivre et al. (2007), and the stack LSTM-based parser of Dyer et al. (2015, henceforce “LSTM Parser”). Default settings are used in all cases.999For MaltParser we use the ArcEager transition set and SVM classifier. Other configurations yielded lower scores. DAGParser and uparse use beam search by default, with a beam size of 5 and 4 respectively. The other parsers are greedy.

5 Results

Table 2 presents our main experimental results, as well as upper bounds for the baseline parsers, reflecting the error resulting from the conversion.101010The low upper bound for remote edges is partly due to the removal of implicit nodes (not supported in bilexical representations), where the whole sub-graph headed by such nodes, often containing remote edges, must be discarded.

DAGParser and uparse are most directly comparable to TUPASparse, as they also use a perceptron classifier with sparse features. TUPASparse considerably outperforms both, where DAGParser does not predict any remote edges in the out-of-domain setting. TurboParser fares worse in this comparison, despite somewhat better results on remote edges. The LSTM parser of Dyer et al. (2015) obtains the highest primary F-score among the baseline parsers, with a considerable margin.

Using a feedforward NN and embedding features, TUPAMLP obtains higher scores than TUPASparse, but is outperformed by the LSTM parser on primary edges. However, using better input encoding allowing virtual look-ahead and look-behind in the token representation, TUPABiLSTM obtains substantially higher scores than TUPAMLP and all other parsers, on both primary and remote edges, both in the in-domain and out-of-domain settings. Its performance in absolute terms, of 73.5% F-score on primary edges, is encouraging in light of UCCA’s inter-annotator agreement of 80–85% F-score on them Abend and Rappoport (2013).

The parsers resulting from tree approximation are unable to recover any remote edges, as these are removed in the conversion.111111We also experimented with a simpler version of TUPA lacking Remote transitions, obtaining an increase of up to 2 labeled F-score points on primary edges, at the cost of not being able to predict remote edges. The bilexical DAG parsers are quite limited in this respect as well. While some of the DAG parsers’ difficulty can be attributed to the conversion upper bound of 58.3%, this in itself cannot account for their poor performance on remote edges, which is an order of magnitude lower than that of TUPABiLSTM.

6 Related Work

While earlier work on anchored121212By anchored we mean that the semantic representation directly corresponds to the words and phrases of the text. semantic parsing has mostly concentrated on shallow semantic analysis, focusing on semantic role labeling of verbal argument structures, the focus has recently shifted to parsing of more elaborate representations that account for a wider range of phenomena Abend and Rappoport (2017).

Grammar-Based Parsing.

Linguistically expressive grammars such as HPSG Pollard and Sag (1994), CCG Steedman (2000) and TAG Joshi and Schabes (1997) provide a theory of the syntax-semantics interface, and have been used as a basis for semantic parsers by defining compositional semantics on top of them (Flickinger, 2000; Bos, 2005, among others). Depending on the grammar and the implementation, such semantic parsers can support some or all of the structural properties UCCA exhibits. Nevertheless, this line of work differs from our approach in two important ways. First, the representations are different. UCCA does not attempt to model the syntax-semantics interface and is thus less coupled with syntax. Second, while grammar-based parsers explicitly model syntax, our approach directly models the relation between tokens and semantic structures, without explicit composition rules.

Broad-Coverage Semantic Parsing.

Most closely related to this work is Broad-Coverage Semantic Dependency Parsing (SDP), addressed in two SemEval tasks Oepen et al. (2014, 2015). Like UCCA parsing, SDP addresses a wide range of semantic phenomena, and supports discontinuous units and reentrancy. In SDP, however, bilexical dependencies are used, and a head must be selected for every relation—even in constructions that have no clear head, such as coordination Ivanova et al. (2012). The use of non-terminal nodes is a simple way to avoid this liability. SDP also differs from UCCA in the type of distinctions it makes, which are more tightly coupled with syntactic considerations, where UCCA aims to capture purely semantic cross-linguistically applicable notions. For instance, the “poss” label in the DM target representation is used to annotate syntactic possessive constructions, regardless of whether they correspond to semantic ownership (e.g., “John’s dog”) or other semantic relations, such as marking an argument of a nominal predicate (e.g., “John’s kick”). UCCA reflects the difference between these constructions.

Recent interest in SDP has yielded numerous works on graph parsing Ribeyre et al. (2014); Thomson et al. (2014); Almeida and Martins (2015); Du et al. (2015), including tree approximation Agić and Koller (2014); Schluter et al. (2014) and joint syntactic/semantic parsing Henderson et al. (2013); Swayamdipta et al. (2016).

Abstract Meaning Representation.

Another line of work addresses parsing into AMRs Flanigan et al. (2014); Vanderwende et al. (2015); Pust et al. (2015); Artzi et al. (2015), which, like UCCA, abstract away from syntactic distinctions and represent meaning directly, using OntoNotes predicates Weischedel et al. (2013). Events in AMR may also be evoked by non-verbal predicates, including possessive constructions.

Unlike in UCCA, the alignment between AMR concepts and the text is not explicitly marked. While sharing much of this work’s motivation, not anchoring the representation in the text complicates the parsing task, as it requires the alignment to be automatically (and imprecisely) detected. Indeed, despite considerable technical effort Flanigan et al. (2014); Pourdamghani et al. (2014); Werling et al. (2015), concept identification is only about 80%–90% accurate. Furthermore, anchoring allows breaking down sentences into semantically meaningful sub-spans, which is useful for many applications Fernández-González and Martins (2015); Birch et al. (2016).

Several transition-based AMR parsers have been proposed: CAMR assumes syntactically parsed input, processing dependency trees into AMR Wang et al. (2015a, b, 2016); Goodman et al. (2016). In contrast, the parsers of Damonte et al. (2017) and Zhou et al. (2016) do not require syntactic pre-processing. Damonte et al. (2017) perform concept identification using a simple heuristic selecting the most frequent graph for each token, and Zhou et al. (2016) perform concept identification and parsing jointly. UCCA parsing does not require separately aligning the input tokens to the graph. TUPA creates non-terminal units as part of the parsing process.

Furthermore, existing transition-based AMR parsers are not general DAG parsers. They are only able to predict a subset of reentrancies and discontinuities, as they may remove nodes before their parents have been predicted Damonte et al. (2017). They are thus limited to a sub-class of AMRs in particular, and specifically cannot produce arbitrary DAG parses. TUPA’s transition set, on the other hand, allows general DAG parsing.131313See Appendix E for a proof sketch for the completeness of TUPA’s transition set.

7 Conclusion

We present TUPA, the first parser for UCCA. Evaluated in in-domain and out-of-domain settings, we show that coupled with a NN classifier and BiLSTM feature extractor, it accurately predicts UCCA graphs from text, outperforming a variety of strong baselines by a margin.

Despite the recent diversity of semantic parsing work, the effectiveness of different approaches for structurally and semantically different schemes is not well-understood Kuhlmann and Oepen (2016). Our contribution to this literature is a general parser that supports multiple parents, discontinuous units and non-terminal nodes.

Future work will evaluate TUPA in a multilingual setting, assessing UCCA’s cross-linguistic applicability. We will also apply the TUPA transition scheme to different target representations, including AMR and SDP, exploring the limits of its generality. In addition, we will explore different conversion procedures Kong et al. (2015) to compare different representations, suggesting ways for a data-driven design of semantic annotation.

A parser for UCCA will enable using the framework for new tasks, in addition to existing applications such as machine translation evaluation Birch et al. (2016). We believe UCCA’s merits in providing a cross-linguistically applicable, broad-coverage annotation will support ongoing efforts to incorporate deeper semantic structures into various applications, such as sentence simplification Narayan and Gardent (2014) and summarization Liu et al. (2015).

Acknowledgments

This work was supported by the HUJI Cyber Security Research Center in conjunction with the Israel National Cyber Bureau in the Prime Minister’s Office, and by the Intel Collaborative Research Institute for Computational Intelligence (ICRI-CI). The first author was supported by a fellowship from the Edmond and Lily Safra Center for Brain Sciences. We thank Wolfgang Maier, Nathan Schneider, Elior Sulem and the anonymous reviewers for their helpful comments.

Appendix A Feature Templates

Figure 6 presents the feature templates used by TUPASparse. All feature templates define binary features. The other classifiers use the same elements listed in the feature templates, but all categorical features are replaced by vector embeddings, and all count-based features are replaced by their numeric value.

For some of the features, we used the notion of head word, defined by the $h^{*}$ function (see Appendix D). While head words are not explicitly represented in the UCCA scheme, these features prove useful as means of encoding word-to-word relations.

Appendix B Extended Presentation of UCCA

This work does not handle two important constructions in the UCCA foundational layer: Linkage, representing discourse relations, and Implicit, representing covert entities. Table 3 shows the statistics of linkage nodes and edges and implicit nodes in the corpora.

Linkage.

Figure 7 demonstrates a linkage relation, omitted from Figure 1(a). The linkage relation is represented by the gray node. $LA$ is link argument, and $LR$ is link relation. The relation represents the fact that the linker “After” links the two parallel scenes that are the arguments of the linkage. Linkage relations are another source of multiple parents for a node, which we do not yet handle in parsing and evaluation.

Implicit units.

UCCA graphs may contain implicit units with no correspondent in the text. Figure 8 shows the annotation for the sentence “A similar technique is almost impossible to apply to other crops, such as cotton, soybeans and rice.”. The sentence was used by Oepen et al. (2015) to compare between different semantic dependency schemes. It includes a single scene, whose main relation is “apply”, a secondary relation “almost impossible”, as well as two complex arguments: “a similar technique” and the coordinated argument “such as cotton, soybeans, and rice.” In addition, the scene includes an implicit argument, which represents the agent of the “apply” relation.

The parsing of these units is deferred to future work, as it is likely to require different methods than those explored in this paper Roth and Frank (2015).

Appendix C Hyperparameter Values

Table 4 lists the hyperparameter values we found for the different classifiers by tuning on the development set. Note that learning rate decay is multiplicative and is applied at each epoch. Mini-batch size is in number of transitions, but a mini-batch must contain only whole sentences.

Appendix D Bilexical Graph Conversion

Here we describe the algorithms used in the conversion referred to in Section 4.

Notation.

Let $L$ be the set of possible edge labels. A UCCA graph over a sequence of tokens $w_{1},\ldots,w_{n}$ is a directed acyclic graph $G=(V,E,\ell)$, where $\ell:E\to L$ maps edges to labels. For each token $w_{i}$ there exists a leaf (terminal) $t_{i}\in V$. A bilexical (dependency) graph over the same text consists of a set $A$ of labeled dependency arcs $(t^{\prime},l,t)$ between the terminals of $G$, where $t^{\prime}$ is the head, $t$ is the dependent and $l$ is the edge label.

Conversion to bilexical graphs.

Let $G=(V,E,\ell)$ be a UCCA graph with labels $\ell:E\rightarrow L$. The conversion to a bilexical graph requires calculating the set $A$. All non-terminals in $G$ are removed.

We define a linear order over possible edge labels $L$ (see Figure 9). The priority order generally places core-like categories before adjunct-like ones, and was decided heuristically. For each node $u\in V$, denote by $h(u)$ its child with the highest-priority edge label. The leftmost edge is chosen in case of a tie. Let $h^{*}(u)$ be the terminal reached by recursively applying $h(\cdot)$ over $u$. For each terminal $t$, we define

[TABLE]

For each edge $(u,v)\in N(t)$, we add $h^{*}(u)$ as a head of $t$ in $A$, with the label $\ell(u,v)$. This procedure is given in Algorithm 1.

Note that this conversion procedure is simpler than the head percolation procedure used for converting syntactic constituency trees to dependency trees Collins (1997), since $h(u)$ (similar to $u$’s head-containing child) depends only on $\ell(u,h(u))$ and not on the sub-tree spanned by $u$, because edge labels in UCCA directly express the role of the child in the parent unit, and are thus sufficient for determining which of $u$’s children contains the head node.

Conversion from bilexical graphs.

The inverse conversion introduces non-terminal nodes back into the graph. As the distinction between low- and high-attaching nodes is lost in the conversion, we assume that attachments are always low-attaching. Let $A$ be a the labeled arc set of a bilexical graph. Iterating over the terminals in topological order according to $A$, we add its members as terminals to graph and create a pre-terminal parent $u_{t}$ for each terminal $t$, with an edge labeled as Terminal between them. The parents of the pre-terminals are determined by the terminal’s parent in the bilexical graph: if $t^{\prime}$ is a head of $t$ in $A$, then $u_{t^{\prime}}$ will be a parent of $u_{t}$. We add an intermediate node in between if $t$ has any dependents in $A$, to allow adding their pre-terminals as children later. Edge labels for the intermediate edges are determined by a rule-based function, denoted by $\mathrm{Label}(t)$. This procedure is given in Algorithm 2.

Appendix E Proof Sketch for Completeness of the TUPA Transition Set

Here we sketch a proof for the fact that the transition set defined in Section 3 is capable of producing any rooted, labeled, anchored DAG. This proves that the transition set is complete with respect to the class of graphs that comprise UCCA.

Let $G=(V,E,\ell)$ be a graph with labels $\ell:E\rightarrow L$ over a sequence of tokens $w_{1},\ldots,w_{n}$. Parsing starts with $w_{1},\ldots,w_{n}$ on the buffer, and the root node on the stack.

First we show that every node can be created, by induction on the node height: every terminal (height zero) already exists at the beginning of the parse (and so does the root node). Let $v\in V$ be of height $k$, and assume all nodes of height less than $k$ can be created. Take any (primary) child $u$ of $v$: its height must be less than $k$. If $u$ is a terminal, apply Shift until it lies at the head of the buffer. Otherwise, by our assumption, $u$ can still be created. Right after $u$ is created, it lies at the head of the buffer. A Shift transition followed by a Nodeℓ(v,u) transition will move $u$ to the stack and create $v$ on the buffer, with the correct edge label.

Next, we show that every edge can be created. Let $(v,u)\in E$ be any edge with parent $v$ and child $u$. Assume $v$ and $u$ have both been created (we already showed that both are created eventually). If either $v$ or $u$ are in the buffer, apply Shift until both are in the stack. If both are in the stack but neither is at the stack top, apply Swap transitions until either moves to the buffer, and then apply Shift. Now, assume either $v$ or $u$ is at the stack top. If the other is not the second element on the stack, apply Swap transitions until it is. Finally, $v$ and $u$ are the top two elements on the stack. If they are in that order, apply Right-Edgeℓ(v,u) (or Right-Remoteℓ(v,u) if the edge between them is remote). Otherwise, apply Left-Edgeℓ(v,u) (or Left-Remoteℓ(v,u) if the edge between them is remote). This creates $(v,u)$ with the correct edge label.

Once all nodes and edges have been created, we can apply Reduce until only the root node remains on the stack, and then Finish. This yields exactly the graph $G$.

Note that the distinction we made between primary and remote transitions is suitable for UCCA parsing. For general graph parsing without this distinction, the Remote transitions can be removed, as well as the single-primary-parent restriction on Edge transition.