Sequential Graph Dependency Parser

TL;DR

This paper introduces a novel set-based, transition-based dependency parsing method capable of handling both projective and non-projective languages, achieving near state-of-the-art results without fixed parsing order.

Contribution

It presents a new set-based learning approach for non-projective dependency parsing that integrates graph, transition, and easy-first parsing techniques.

Findings

Achieves near state-of-the-art accuracy on multiple languages.

Effectively handles both projective and non-projective dependencies.

Does not assume a fixed parsing order.

Abstract

We propose a method for non-projective dependency parsing by incrementally predicting a set of edges. Since the edges do not have a pre-specified order, we propose a set-based learning method. Our method blends graph, transition, and easy-first parsing, including a prior state of the parser as a special case. The proposed transition-based method successfully parses near the state of the art on both projective and non-projective languages, without assuming a certain parsing order.

Tables

Table 1. Table 1: Development set UAS for single vs. multi-step methods. (U) is uniform oracle and roll-in, (C) is coaching with greedy valid roll-in ( β = 0.5 𝛽 0.5 \beta=0.5 ). D & M (2017) is an abbreviation for Dozat and Manning ( 2017 ) .

	En	De	Grc	Zh
D & M (2017)	91.14	90.38	78.99	86.50
Qi et al. (2018)	92.11	89.46	81.35	86.73
One-Step	91.74	91.07	79.60	86.61
Recurrent (U)	91.92	91.02	79.15	86.69
Recurrent (C)	91.99	91.19	79.93	86.77

Table 2. Table 2: Varying oracle and roll-in policies on German. (U), (C), (A) refer to uniform, coaching, and annealing, respectively. The π coach ∗ subscript superscript 𝜋 coach \pi^{*}_{\text{coach}} and π θ valid superscript subscript 𝜋 𝜃 valid \pi_{\theta}^{\text{valid}} roll-ins are mixtures with a uniform oracle, with β = 0.5 𝛽 0.5 \beta=0.5 for coaching (C), and β 𝛽 \beta linearly annealed by 0.02 every 2000 steps for annealing (CA).

Oracle	Roll-in	UAS	Loss
Linear	${\pi }_{\text{linear}}^{\ast }$	81.03	0.04
U	${\pi }_{\text{unif}}^{\ast }$	91.02	0.35
C	${\pi }_{\text{unif}}^{\ast }$	91.04	0.17
U	${\pi }_{\text{coach}}^{\ast }$	90.93	0.45
C	${\pi }_{\text{coach}}^{\ast }$	91.17	0.33
CA	${\pi }_{\text{coach}}^{\ast }$	90.89	0.34
U	${\pi }_{\theta }^{\text{valid}}$	90.99	0.51
C	${\pi }_{\theta }^{\text{valid}}$	91.19	0.31
CA	${\pi }_{\theta }^{\text{valid}}$	90.91	0.30

Table 3. Table 3: Test set results (UAS) on datasets from the CoNLL 2018 shared task with greater than 200k examples, plus the Ancient Greek (GRC) and Chinese (ZH) datasets. Bold denotes the highest UAS on each dataset.

	Ours	Qi et al. (2018)
AR	88.22	88.35
CA	94.13	94.13
CS (CAC)	93.53	93.22
CS (PDT)	93.80	93.21
DE	88.39	87.21
EN (EWT)	91.28	91.21
ES	93.70	93.38
ET	89.56	89.40
FR (GSD)	91.07	90.90
GRC (Perseus)	80.90	82.77
HI	96.78	96.78
IT (ISDT)	94.06	94.24
KO (KAIST)	91.02	90.55
LA (ITTB)	93.66	93.00
NO (Bokmaal)	94.63	94.27
NO (Nynorsk)	94.44	94.02
PT	91.22	91.67
RU (SynTagRus)	94.57	94.42
ZH	87.31	88.49

Equations

$$H^{\text{enc}}$$

$$H_t^{\text{head}},H_t^{\text{dep}}$$

$$S_t$$

$$E_t$$

$$H^{\text{enc}}$$

$$H^{\text{head}},H^{\text{dep}}$$

$$S$$

$$E$$

$$p((j\to i)|x)$$

$$W,h_t$$

$$H_t^{\text{head}}$$

$$H_t^{\text{dep}}$$

$$S_t^{\Delta }$$

$$S_t$$

$$\pi ((i\to j)|E_{<t},x)$$

$$E_t$$

$$f_{\text{emb}}(E_t)$$

$$e_{\text{edge}}$$

$$e_{\text{head}}$$

$$e_{\text{dependent}}$$

$${\pi }_{\theta }((i,j)|{\hat{E}}_{<t},x),$$

$${\mathbb{E}}_{x\sim \mathcal{D}}{\mathbb{E}}_{s_1,\dots ,s_{|x|}\sim {\pi }^{\text{in}}}\mathcal{C}({\pi }_{\theta },{\pi }^{\text{out}},s_t).$$

$$\mathcal{C}({\pi }_{\theta },{\pi }^{\text{out}},s)$$

$$E_{\text{free}}^t$$

$${\pi }^{\ast }((i,j)|E_{\text{free}}^t)=\{\begin{array}{ll}{p}_{ij}& (i,j)\in E_{\text{free}}^t\\ 0& \text{otherwise.}\end{array}$$

$${\pi }_{\text{unif}}^{\ast }((i,j)|E_{\text{free}}^t)=\{\begin{array}{ll}\frac{1}{|E_{\text{free}}^t|}& (i,j)\in E_{\text{free}}^t\\ 0& \text{otherwise.}\end{array}$$

$${\pi }_{\text{coaching}}^{\ast }((i,j)|E_{\text{free}}^t)\propto {\pi }_{\text{unif}}^{\ast }(\cdot |E_{\text{free}}^t){\pi }_{\theta }(\cdot |E_{<t},X).$$

$$\beta {\pi }_{\text{unif}}^{\ast }+(1-\beta ){\pi }_{\text{coaching}}^{\ast },$$

Full text

1 Introduction

Dependency parsing methods can be categorized as graph-based and transition-based. Typical graph-based methods support non-projective parsing, but introduce independence assumptions and rely on external decoding algorithms. Conversely, transition-based methods model joint dependencies, but without modification are typically limited to projective parses.

There are two recent exceptions of interest here. Ma et al. (2018) developed the Stack-Pointer parser, a transition-based, non-projective parser that maintains a stack populated in a top-down, depth-first manner, and uses a pointer network to determine the dependent of the stack’s top node, resulting in a transition sequence of length $2n-1$. Recently, Fernández-González and Gómez-Rodríguez (2019) developed a variant of the Stack-Pointer parser which parses in $n$ steps by traversing the sentence left-to-right, selecting the head of the current node in the traversal, while incrementally checking for, and prohibiting, cycles.

We take inspiration from both graph-based and transition-based approaches by viewing parsing as sequential graph generation. In this view, a graph is incrementally built by adding edges to an edge set. No distinction between projective and non-projective trees is necessary. Since edges do not have a pre-specified order, we propose a set-based learning method. Like Fernández-González and Gómez-Rodríguez (2019), our parser runs in $n$ steps. However, our learning method and transitions do not impose a left-to-right parsing order, allowing easy-first Tsuruoka and Tsujii (2005); Goldberg and Elhadad (2010) behavior. Experimentally, we find that the proposed method can yield a sequential parser with preferred, input-dependent generation orders and performance gains over strong one-step methods.

2 Graph Dependency Parser

Given a sentence $x=x_{1},\ldots,x_{N}$, a dependency parser constructs a graph $G=(V,E)$ with $V=(x_{0},x_{1},\dots,x_{N})$ and $E=\{(i,j)_{1},\ldots(i,j)_{N}\}$, where $x_{0}$ is a special root node, and $E\subset\mathcal{E}$ forms a dependency tree.111See properties (1-5) in Appendix A.

We describe a family of sequential graph-based dependency parsers. A parser in this family generates a sequence of graphs where $V$ is fixed and $E=\bigcup_{t=1}^{T}E_{t}$:

[TABLE]

Steps (2-4) run for $T\leq N$ time-steps. At each time-step, first $f_{V}$ generates head and dependent representations for each vertex, $H_{t}^{\cdot}\in\mathbb{R}^{V\times d_{H}}$, based on vertex representations $H^{\text{enc}}\in\mathbb{R}^{V\times d}$, previously predicted edges $E_{<t}$, and a recurrent state $h_{t-1}\in\mathbb{R}^{d}$. Then $f_{E}$ computes a score for every possible edge, $S_{t}\in\mathbb{R}^{V\times V}$, and the scores are used by $f_{\text{dec}}$ to predict a set of edges $E_{t}$.

This general sequential family includes the biaffine parser of Dozat and Manning (2017) as a one-step special case, as well as a recurrent variant which we discuss below.

2.1 Biaffine One-Step

The Biaffine parser of Dozat and Manning (2017) is a one-step variant, implementing steps (1-4) using a bidirectional LSTM, head and dependent neural networks, a biaffine scorer, and a maximum spanning tree decoder, respectively:

[TABLE]

where each row of scores $S^{(i)}$ is interpreted as a distribution over $i$’s potential head nodes:

[TABLE]

and $\text{MST}(\cdot)$ is an off-the-shelf maximum-spanning-tree algorithm. This model assumes conditional independence of the edges.

2.2 Recurrent Weight

We propose a variant which iteratively adjusts a distribution over edges at each step, based on the predictions so far. A recurrent function generates a weight matrix $W$ which is used to form vertex embeddings and in turn adjust edge scores.

Specifically, we first obtain an initial score matrix $S_{0}$ using the biaffine one-step parser (2.1), and initialize a recurrent hidden state $h_{0}$ using a linear transformation of $f_{\text{enc}}$’s final hidden state. Then $f_{V}$ is defined as:

[TABLE]

and $f_{\text{E}}(H^{\text{head}}_{t},H^{\text{dep}}_{t},S_{t-1})$ is defined as:

[TABLE]

where $t$ ranges from 1 to $N$, $W\in\mathbb{R}^{d_{\text{emb}}\times d_{H}}$, and each $\text{emb}_{(\cdot)}:\mathbb{N}\rightarrow\mathbb{R}^{d_{\text{emb}}}$ is a learned embedding layer, yielding $\text{emb}_{(\cdot)}(0,\ldots,N)$ in $\mathbb{R}^{V\times d_{\text{emb}}}$. We use a bidirectional LSTM as $f_{\text{enc}}$.

The scores at each step yield a distribution over all $V\times V$ edges, which we denote by $\pi$:

[TABLE]

Unlike the one-step model, this recurrent model can predict edges based on past predictions.

Inference

We must ensure the incrementally decoded edges $E=\bigcup_{t=1}^{T}E_{t}$ form a valid dependency tree. To do so, we choose $f_{\text{dec}}$ to be a decoder which greedily selects valid edges,

[TABLE]

which we refer to as the valid decoder, detailed in Appendix A. We only predict one edge per step $(|E_{t}|=1)$, leaving the setting of multiple predictions per step as future work.

Embedding Edges

We embed a predicted edge $E_{t}=\{\hat{(i,j)}\}$ as:

[TABLE]

where $H^{\text{enc}}_{(\cdot)}\in\mathbb{R}^{d}$ are row vectors, $W_{e}\in\mathbb{R}^{d_{e}\times d}$ is a learned weight matrix, $\text{emb}_{(\cdot)}$ are learned embedding layers, and ; is concatenation.

Future Work

The proposed method does not specifically require a BiLSTM encoder, LSTM, or the BiAffine function. For instance, $f_{\text{V}}$ could use a Transformer Vaswani et al. (2017) to output states that are linearly transformed into $H^{\text{head}}$ and $H^{\text{dep}}$. Additionally, partial graphs $(V,E_{<t})$ might be embedded using neural networks specifically designed for graphs Gilmer et al. (2017). Finally, predicting edge sets of size greater than 1 could potentially be achieved using a partially-autoregressive model, trained with a ‘masked edges’ objective, similar to recent work in machine translation with conditional masked language models Ghazvininejad et al. (2019). Each call to $f_{V}$ would involve a separate forward pass which calls a Transformer $f_{\text{enc}}$. The partial tree is encoded via non-masked inputs to $f_{\text{enc}}$. $f_{\text{E}}$ corresponds to having $V$ outputs, each a distribution over $V$ edges. The multi-step decoder (Appendix A) might be used at test time.

3 Learning

In this paper, we restrict to the case of predicting a single edge $\hat{(i,j)}$ per step, so that the recurrent weight model generates a sequence of edges with the goal of matching a target edge set, i.e. $\bigcup_{t=1}^{N}\hat{(i,j)}_{t}=E$. Since the target edges $E$ are a set, the model’s generation order is not determined a priori. As a result, we propose to use a learning method that does not require a pre-specified generation order and allows the model to learn input-dependent orderings.

Our proposed method is based on the multiset loss Welleck et al. (2018) and its recent extensions for non-monotonic generation Welleck et al. (2019). The method is motivated from the perspective of learning-to-search Daumé III et al. (2009); Chang et al. (2015), which involves learning a policy $\pi_{\theta}$ that mimics an oracle policy $\pi^{*}$. The policy maps states to distributions over actions.

For the proposed graph parser, an action is an edge $(i,j)\in\mathcal{E}$, and a state $s_{t}$ is an input sentence $x$ along with the edges predicted so far, $\hat{E}_{<t}$. The policy is a conditional distribution over $\mathcal{E}$,

[TABLE]

such as the distribution in equation (5).

Learning consists of minimizing a cost, computed by first sampling states from a roll-in policy $\pi^{\text{in}}$, then using a roll-out policy $\pi^{\text{out}}$ to estimate cost-to-go for all actions at the sampled states. Formally, we minimize the following objective with respect to $\theta$:

[TABLE]

This objective involves sampling a sentence $x$ from a dataset, sampling a sequence of edges from the roll-in policy, then computing a cost $\mathcal{C}$ at each of the resulting states. We now describe our choices of $\mathcal{C}$, $\pi^{\text{out}}$, $\pi^{*}$, and $\pi^{\text{in}}$, and evaluate them later in the experiments (4).

3.1 Cost Function and Roll-Out

Following Welleck et al. (2018, 2019) we use a KL-divergence cost:

[TABLE]

We use the oracle $\pi^{*}$ as the roll-out $\pi^{\text{out}}$.

3.2 Oracle

Based on the free labels set in Welleck et al. (2018), we first define a free edge set containing the un-predicted target edges at time $t$:

[TABLE]

where $E_{\text{free}}^{0}=E$. We then construct a family of oracle policies that place non-zero probability mass only on free edges:

[TABLE]

We now describe several oracles by varying how $p_{ij}$ is defined.

Uniform

This oracle treats each permutation of the target edge set as equally likely by assigning a uniform probability to each free edge:

[TABLE]

Coaching

Motivated by He et al. (2012); Welleck et al. (2019), we define a coaching oracle which weights free edges by $\pi_{\theta}$:

[TABLE]

This oracle prefers certain edge permutations over others, reinforcing $\pi_{\theta}$’s preferences. The coaching and uniform oracles can be mixed to ensure each free edge receives probability mass:

[TABLE]

where $\beta\in[0,1].$

Annealed Coaching

This oracle begins with the uniform oracle, then anneals towards the coaching oracle as training progresses by annealing the $\beta$ term in (10). This may prevent the coaching oracle from reinforcing sub-optimal permutations early in training.

Linearized

This oracle uses a deterministic function to linearize an edge set $E$ into a sequence $E_{\text{seq}}$. The oracle selects the $t$’th element of $E_{\text{seq}}$ at time $t$ with probability 1. We linearize an edge set in increasing edge-index order: $(i_{1},j_{1})$ precedes $(i_{2},j_{2})$ if $(i_{1},j_{1})<(i_{2},j_{2})$. This oracle serves as a baseline that is analogous to the fixed generation orders used in conventional parsers.

3.3 Roll-In

The roll-in policy determines the state distribution that $\pi_{\theta}$ is trained on, which can address the mismatch between training and testing state distributions Ross et al. (2011); Chang et al. (2015) or narrow the set of training trajectories. We evaluate several alternatives:

uniform $(i,j)\sim\pi^{*}_{\text{unif}}$ 2. 2.

coaching $(i,j)\sim\pi_{\theta}\odot\pi^{*}_{\text{unif}}$ 3. 3.

valid-policy $(i,j)\sim\text{valid}(\pi_{\theta})$

where $\text{valid}(\pi_{\theta})$ is the set of edges that keeps the predicted tree as a valid dependency tree. The coaching and valid-policy roll-ins choose edge permutations that are preferred by the policy, with valid-policy resembling test-time behavior.

4 Experiments

In Experiments 4.1 and 4.2 we evaluate on English, German, Chinese, and Ancient Greek since they vary with respect to projectivity, size, and performance in Qi et al. (2018). Based on these development set results, we then test our strongest model on a large suite of languages (4.3).

Experimental Setup

Experiments are done using datasets from the CoNLL 2018 Shared Task Zeman et al. (2018). We build our implementation from the open-source version of Qi et al. (2018)222https://github.com/stanfordnlp/stanfordnlp., and use their experimental setup (e.g. pre-processing, data-loading, pre-trained vectors, evaluation) which follows the shared task setup. Our model uses the same encoder from Qi et al. (2018). For the Qi et al. (2018) baseline, we use their pretrained models333https://stanfordnlp.github.io/stanfordnlp/installation_download.html. and evaluation script. For the Dozat and Manning (2017) baseline, we use the Qi et al. (2018) implementation with auxiliary outputs and losses disabled, and train with the default hyper-parameters and training script. For our models only, we changed the learning rate schedule (and model-specific hyper-parameters), after observing diverging loss in preliminary experiments with the default learning rate. Our models did not require the additional AMSGrad technique used in Qi et al. (2018). We evaluate validation UAS every 2k steps (vs. 100 for the baseline). Models are trained for up to 100k steps, and the model with the highest validation unlabeled attachment score (UAS) is saved.

4.1 Multi-Step Learning

In this experiment we evaluate the sequential aspect of the proposed recurrent model by comparing it with one-step baselines. We compare against a baseline (‘One-Step’) that simply uses the first step’s score matrix $S_{0}$ from the recurrent weight model and minimizes (6) for one time-step using a uniform oracle. At test time the valid decoder uses $S_{0}$ for all timesteps. We also compare against the biaffine one-step model of Dozat and Manning (2017) which uses Chu-Liu-Edmonds maximum spanning tree decoding instead of valid decoding. Since we only evaluate UAS, we disable its edge label output and loss. Finally, we compare against Qi et al. (2018) which is based on Dozat and Manning (2017) plus auxiliary losses for length and linearization prediction.

Results are shown in Table 1, including results for a recurrent model trained with coaching (‘Recurrent (C)’) using a mixture (eq. 10) with $\beta=0.5$. The one-step baseline is strong, even outperforming the uniform recurrent variant on some languages. The recurrent weight model with coaching, however, outperforms the one-step and Dozat and Manning (2017) baselines on all four languages. Adding in auxiliary losses to the Dozat and Manning (2017) model yields improved UAS as seen in the Qi et al. (2018) performance, suggesting that our proposed recurrent model might be improved further with auxiliary losses.

Temporal Distribution Adjustment

Figure 1 shows per-step edge distributions on an eight-edge example. The recurrent weight variants learned to adjust their distributions over time based on past predictions. The model trained with the uniform oracle has a decreasing number of high probability edges per step since it aims to place equal mass on each free edge $(i,j)\in\hat{E}^{t}_{\text{free}}$. The model trained with coaching learned to prefer certain free edges over others, but with $\beta=0.5$ the uniform term in the loss still encourages placing mass on multiple edges per step. By annealing $\beta$, however, the coaching model exhibits vastly different behavior than the uniform-trained policy. The low entropy distributions at early steps followed by higher entropy distributions later on (e.g. $t\in\{5,6\}$) may indicate easy-first behavior.

4.2 Oracle and Roll-In Choice

In this experiment, we study the effects of varying the oracle and roll-in distributions. Table (2) shows results on German, analyzed below. Models trained with coaching (C) use a mixture with $\beta=0.5$, after observing lower UAS in preliminary experiments with lower $\beta$. The $\pi^{*}_{\text{coach}}$ and $\pi^{\text{valid}}_{\theta}$ roll-ins use a mixture with $\beta=0.5$ and greedy decoding, which generally outperformed stochastic sampling.

Set-Based Learning

The model trained with the linearized oracle (UAS 81.03), which teaches the model to adhere to a pre-specified generation order, significantly under-performs the set-based models (UAS $\geq 90.89$), which do not have a pre-specified generation order and can in principle learn strategies such as easy-first.

Coaching

Models trained with coaching (C, UAS $\geq 91.04$) had higher UAS and lower loss than models trained with the uniform oracle (U, UAS $\leq 91.02$), for all roll-in methods. This suggests that for the proposed model, weighting free edges in the loss based on the model’s distribution is more effective than a uniform weighting.

Annealing the $\beta$ parameter generally did not further improve UAS (CA vs. C), possibly due to the annealing schedule or overfitting; despite lower losses with annealing, eventually validation UAS decreased as training progressed.

Roll-In

With the coaching oracle (C), the choice of roll-in impacted UAS, with coaching roll-in ($\pi^{*}_{\text{coach}}$, 91.17) and valid roll-in ($\pi_{\theta}^{\text{valid}},91.19)$ achieving higher UAS than uniform oracle roll-in $(\pi^{*}_{\text{unif}},91.04)$. This suggests that when using coaching, narrowing the set of training trajectories to those preferred by the policy may be more effective than sampling uniformly from the set of all correct trajectories. Based on these results, we use the coaching oracle and valid roll-in for training our final model in the next experiment.

4.3 CoNLL 2018 Comparison

In this experiment, we evaluate our best model on a diverse set of multi-lingual datasets. We use the CoNLL 2018 shared task datasets that have at least 200k examples, along with the four datasets used in the previous experiments. We train a recurrent weight model for each dataset using the coaching oracle and valid roll-in. We compare against Qi et al. (2018) which placed highly in the CoNLL 2018 competition, reporting test UAS evaluated using their pre-trained models.

Table 3 shows the results on the 19 datasets from 17 different languages. The proposed model trained with coaching achieves a higher UAS than the Qi et al. (2018) model on 12 of the 19 datasets, plus two ties.

5 Related Work

Transition-based dependency parsing has a rich history, with methods generally varying by the choice of transition system and feature representation. Traditional stack-based arc-standard and arc-eager Yamada and Matsumoto (2003); Nivre (2003) transition systems only parse projectively, requiring additional operations for pseudo-non-projectivity Gómez-Rodríguez et al. (2014) or projectivity Nivre (2009), while list-based non-projective systems have been developed Nivre (2008). Recent variations assume a generation order such as top-down Ma et al. (2018) or left-to-right Fernández-González and Gómez-Rodríguez (2019). Other recent models focus on unsupervised settings Kim et al. (2019). Our focus here is a non-projective transition system and learning method which does not assume a particular generation order.

A separate thread of research in sequential modeling has demonstrated that generation order can affect performance Vinyals et al. (2015), both in tasks with set-structured outputs such as objects Welleck et al. (2017, 2018) or graphs Li et al. (2018), and in sequential tasks such as language modeling Ford et al. (2018). Developing models with relaxed or learned generation orders has picked up recent interest Welleck et al. (2018, 2019); Gu et al. (2019); Stern et al. (2019). We investigate this for dependency parsing, framing the problem as sequential set generation without a pre-specified order.

Finally, our work is inspired by techniques for improving upon maximum likelihood training through error exploration and dynamic oracles Goldberg and Nivre (2012, 2013), and related techniques in imitation learning for structured prediction Daumé III et al. (2009); Ross et al. (2011); He et al. (2012); Goodman et al. (2016). In particular, our formulation is closely related to the framework of Chang et al. (2015), where our oracle can be seen as an optimal roll-out policy which computes action costs without explicit roll-outs.

6 Conclusion

We described a family of dependency parsers which construct a dependency tree by generating a sequence of edge sets, and a learning method that does not presuppose a generation order. Experimentally, we found that a ‘coaching’ method, which weights actions in the loss according to the model, improves parsing accuracy compared to a uniform weighting and allows the parser to learn preferred, input-dependent generation orders. The model’s sequential aspect, along with the coaching method and training on a state distribution which resembles the model’s own behavior, yielded improvements in unlabeled dependency parsing over strong one-step baselines.

Acknowledgements

This work was partly supported by STCSM 17JC1404100/1.

Appendix A Sequential Valid Decoder

We wish to sequentially sample $E_{1},E_{2},\ldots,E_{T}$ from score matrices $S_{1},S_{2},\ldots,S_{T}$, respectively, such that $E=\bigcup_{t}E_{t}$ is a dependency tree. A dependency tree must satisfy:

The root node has no incoming edges. 2. 2.

Each non-root node has exactly one incoming edge. 3. 3.

There are no duplicate edges. 4. 4.

There are no self-loops. 5. 5.

There are no cycles.

We first consider predicting one edge per step $|E_{t}|=1$, then address the case $|E_{t}|\geq 1$.

One Edge Per Step

Let $x=x_{0},x_{1},\ldots,x_{N}$ where $x_{0}$ is a root node. We define a function $f_{\text{valid}}(S_{t},E_{<t})\rightarrow(i,j)$ which chooses the highest scoring edge $(i,j)$ such that $E_{<t}\cup\{(i,j)\}$ is a dependency tree, given edges $E_{<t}$ and scores $S_{t}$. We represent $E_{<t}$ as an adjacency matrix $A_{<t}$, and implement $f_{\text{valid}}(S_{t},A_{<t})$ by masking $S_{t}$ to yield scores $\tilde{S}$ that satisfy (1-5) as follows:

$\tilde{S}_{\cdot,0}=-\infty$ 2. 2.

$A_{i,j}=1$ implies $\tilde{S}_{\cdot,j}=-\infty$ 3. 3.

$A_{i,j}=1$ implies $\tilde{S}_{i,j}=-\infty$ 4. 4.

$\tilde{S}_{i,i}=-\infty$ for all $i$ 5. 5.

$R_{i,j}=1$ implies $\tilde{S}_{j,i}=-\infty$, where $R\in\{0,1\}^{N\times N}$ is the reachability matrix (transitive closure) of $A$. That is, $R_{i,j}=1$ when there is a directed path from $i$ to $j$. 444The reachability matrix $R$ can be computed with batched matrix multiplication as $\sum_{k=1}^{t}A^{k}$ where $t$ is the maximum path length; other methods could potentially improve speed.

The selected edge is then $\arg\max_{(i,j)}\tilde{S}_{i,j}$.

A full tree is decoded by calling $f_{\text{valid}}$ for $T$ steps, using the current step scores $S_{t}$ and an adjacency matrix $A_{<t}=\bigcup_{t^{\prime}=1}^{t-1}\{(i,j)_{t^{\prime}}\}$.

Multiple Edges Per Step

To decode multiple edges per step, i.e. $|E_{t}|\geq 1$, we propose to repeatedly call $f_{\text{valid}}$, adding the returned edge to the adjacency matrix after each call, and stopping once the returned edge’s score is below a pre-defined threshold $\tau$.