Frame-Semantic Parsing with Softmax-Margin Segmental RNNs and a Syntactic Scaffold

Introduction

Frame-semantic parsing (Gildea and Jurafsky, 2002) is the task of identifying the semantic frames evoked in text, along with their arguments, formalized in the FrameNet project (Baker et al., 1998). An example sentence and its frame-semantic annotations are shown in Figure 1.

Frame-semantics has shown to be useful in question answering Shen and Lapata (2007), text-to-scene generation Coyne et al. (2012), dialog systems Chen et al. (2013) and social-network extraction Agarwal et al. (2014), among others.

Existing frame-semantic parsers rely on syntactic parsing in two ways: first, syntax-based rules are used to prune out spans of text that are unlikely to contain any frame’s argument; and second, syntax provides features for argument identification and labeling Das et al. (2014); FitzGerald et al. (2015); Täckström et al. (2015); Roth and Lapata (2015). Syntactic parsing comes at a computational cost, though, and syntactic filters are known to be too strict. Indeed, Täckström et al. (2015) found that filtering heuristics based on predicted dependencies bounded recall below 72.6%. Recent research has begun to question whether syntax is necessary for semantic analysis (Zhou and Xu, 2015; Swayamdipta et al., 2016; He et al., 2017; Peng et al., 2017), and here, we begin by posing the same question for frame semantics in particular.

Our first model presents the first syntax-free frame-semantic argument identification system (§3), which achieves competitive results. We follow Kong et al. (2016) in combining bidirectional RNNs with a semi-Markov CRF—a model known as the segmental RNN (SegRNN)—to segment and label the sentence relative to each frame. We introduce the softmax-margin SegRNN (§3.4), a modification to the model that we use to encourage recall over precision. This approach to argument identification forgoes syntactic filtering and syntactic features completely. We also release a syntax-free frame identification system (§A). However, the focus of this paper is argument id. For controlled comparison, we use the results from a state-of-the art frame id system Hermann et al. (2014), which uses syntactic features.

In the rest of the paper, using this basic model as a foundation, we test whether incorporating syntax is still worthwhile. In the first setting (§4), we add standard features derived from either a dependency parser or a phrase-structure parser to the softmax-margin SegRNN. We find that this syntactic pipelining approach improves over both our syntax-free model and achieves state-of-the-art performance. This finding confirms that syntactic features are beneficial, even on top of expressive neural representation learning.

In our second setting (§5), we preserve most of the benefit of syntactic features without the accompanying computational cost of feature extraction or syntactic parsing. We incorporate the training objective of our syntax-free model into a multitask setting where the second task is unlabeled constituent identification (i.e., a separate binary decision for each span). This task is trained on the Penn Treebank, sharing the underlying sentence representation with the frame-semantic parser. This syntactic scaffoldWe borrow the term scaffolding from developmental psychology (Wood et al., 1976) to describe a support task during learning that is eventually discarded. task offers useful guidance to the frame-semantic model, leading to performance on par with our models that use syntactic features. This approach also achieves state-of-the-art performance, despite not involving a syntactic parser during training or testing.

the softmax-margin SegRNN, a recall-oriented extension to segmental RNNs, for frame-semantic argument identification without any syntactic information (§3),

the addition of syntactic information to the above, achieving state-of-the-art perfomance, using:

a pipelined approach, incorporating features from automatic dependency or phrase-structure parsers (§4),

a syntactic scaffolding approach, discarding the need for a syntactic parser altogether (§5).

Our open-source implementation is available as open-SESAME (SEmi-markov Softmax-margin ArguMEnt parser) at https://github.com/Noahs-ARK/open-sesame/.

Frame-Semantic Parsing Task

The Berkeley FrameNet project Baker et al. (1998); Ruppenhofer et al. (2010) provides a lexicon of 1,020 semantic frames,Release 1.5. Release 1.7 has 1,222 frame annotations; see http://framenet.icsi.berkeley.edu. a corpus of sentences annotated with frames from that inventory, and a corpus of annotated exemplar sentences (not used in this work).

Each frame represents a kind of event, situation, or relationship, and has a set of frame elements (semantic roles) associated with it Fillmore (1976). In a sentence, frames are evoked by targets, which are words or phrases. The FrameNet lexicon maintains a list of lexical units for each frame, which are lemma and part-of-speech pairs that can evoke that frame. For example, in Figure 1, the target drying up has dry up.v as its lexical unit, associated with the frame Becoming_dry. Our main use of the FrameNet lexicon, following earlier work, is as a mapping between frames and the roles they might take.

Frame-semantic parsing is usually performed as a pipeline of tasks: target identification (which words or expressions evoke frames?), frame identification (which frame does each target evoke?), and then argument identification (for each frame $f$, and each of its possible roles in the FrameNet-defined set $\mathcal{Y}_{f}$, which span of text provides the argument?). Target identification conventionally relies on heuristics, and frame identification is usually treated as a classification problem Das et al. (2014). The focus of this paper is argument identification, and we evaluate variations of our approach on both gold-standard frame input and on the output of state-of-the-art frame identification (FitzGerald et al., 2015).

Segmental RNN for Argument Identification

Our first model for argument identification is a segmental RNN (SegRNN; Kong et al., 2016), a variant of a semi-Markov conditional random field (Sarawagi et al., 2004) whose span representations are computed using bidirectional RNNs. Semi-Markov CRFs model a conditional distribution over labeled segmentations of an input sequence; precisely the set of outputs possible for a single frame’s argument identification task. They provide $O(n^{2})$ inference using dynamic programming (§3.4). This can be reduced to $O(nb)$ by filtering out segments longer than $b$ tokens (we use $b=20$, which prunes less than 1% of gold arguments).

Semi-Markov models are more general than BIO tagging schemes, which have been used successfully in PropBank SRL (Collobert et al., 2011; Zhou and Xu, 2015, inter alia). The semi-Markov assumption allows scoring functions that directly model an entire variable-length segment (rather than fixed-length label n-grams), while retaining exact inference and a linear runtime. Relatedly, Täckström et al. (2015) introduced a dynamic program that allows direct modeling of variable-length segments as well as enforcing constraints such as certain roles being filled at most once. Its runtime is linear in the sentence length, but exponential in the number of roles. The semi-Markov CRF’s inference algorithm is a relaxed special case of their method, with fewer constraints and without the exponential runtime constant.

SegRNNs use continuous vector representations of spans. In past work, they have been applied to joint word segmentation and part-of-speech tagging for Chinese (Kong et al., 2016) and to speech recognition (Lu et al., 2016).

Given an input $\bm{x}$, a SegRNN defines a conditional distribution $p(\bm{s}\mid\bm{x})$. Every segment $s_{i}$ is given a real-valued score $\phi(s_{i},\bm{x})$, detailed in §3.3. The score of a segmentation $\bm{s}$ is the sum of the scores of its segments:

These scores are exponentiated and normalized to define the probability distribution. The sum-product variant of the semi-Markov dynamic programming algorithm is used to calculate the normalization term (required during learning). At test time, the max-product variant returns the most probable segmentation,

The parameters of SegRNNs are learned to maximize a criterion related to the conditional log-likelihood of the gold-standard segments in the training corpus (§3.4). The learner evaluates and adjusts segment scores $\phi(s_{i},\bm{x})$ (§3.3) for every span in the sentence, which in turn involves learning embedded representations for all spans (§3.1). Representations of the target, lexical unit, frame, and frame elements are also learned (§3.2). The entire model is illustrated in Fig. 2; we discuss the details from the bottom up.

We use two bidirectional long short-term memory networks (Hochreiter and Schmidhuber, 1997; Schuster and Paliwal, 1997; Graves, 2012, biLSTMs;) over the input sentence to obtain continuous representations of each token and each candidate span (all subsequences of length $\leq 20$).

At each word position $q$, we give as input to the first (token) biLSTM an input vector $\mathbf{v}_{q}=[\mathbf{d}_{q};\mathbf{e}_{q};\mathbf{o}_{q};\bm{\gamma}_{q}]$, where $\mathbf{d}_{q}$ is a learned embedding of the word type, $\mathbf{e}_{q}$ is a fixed pre-trained embedding of the word type, $\mathbf{o}_{q}$ is a learned embedding of the part-of-speech tag, and $\bm{\gamma}_{q}$ is the distance of the word from the beginning of the target. This yields a hidden state vector $\mathbf{h}^{\text{tok}}_{q}$ at the $q$th token, which is a contextualized representation of the token:

The second biLSTM embeds every candidate span, using the hidden representations from the token biLSTM as input:

These span embeddings are calculated efficiently, sharing computation where possible; for details, see Kong et al. (2016).

2 Input Target and Frame Embeddings

3 Segment Scores

The score of a segment should capture the interaction between the span, the frame element label, the target, the lexical unit, and the frame. We form a vector $\mathbf{v}_{s}$ for a segment $s=\langle i,j,y\rangle$ by concatenating the span embedding $\mathbf{h}^{\text{span}}_{i:j}$, a learned embedding $\mathbf{v}_{y}$ for frame element $y\in\mathcal{Y}_{f}\cup\{\textsc{null}\}$, and two additional one-hot features (denoted $\bm{\mu}$): the binned length of the span, and the span’s position relative to the target (before, after, overlapping, or within):

Then the representation is passed through a rectified linear unit Nair and Hinton (2010) to get the segment score:

where the matrix $\mathbf{W}_{1}$ and the vector $\mathbf{w}_{2}$ are model parameters. Note that null-labeled spans are handled in the same way as other labeled spans. Our formalization allows spurious ambiguity, in that the spaces in between arguments may segmented into any number of null segments. We experimented with requiring null segments to have length $1$ to eliminate the ambiguity, but found that performance dropped significantly.

4 Softmax-Margin Segmental RNNs

Most spans are not arguments; we therefore train to maximize a criterion that biases the model to favor recall (Mohit et al., 2012). Known as the softmax-margin (Gimpel and Smith, 2010), this criterion alters the partition function with a cost function that more strongly penalizes false negatives:

where FN counts false negatives, FP counts false positives, and $\alpha\geqslant 1$ is a hyperparameter tuned on the development set. In order to keep inference tractable, the cost function needs to factorize by predicted span (so $\text{cost}(\bm{s},\bm{s}^{*})=\sum_{i=1}^{m}{\text{cost}(s_{i},\bm{s}^{*})}$). But a false negative is not a property of an individual predicted span. We get around this by noting that a predicted span forces a false negative if it partially overlaps with a gold span. To avoid double counting, as multiple predicted spans may overlap with a gold span, we assign blame only to the span that contains the first token ($i^{*}$) of the missing gold span: $\text{cost}(\langle i,j,y\rangle,\bm{s}^{*})=$

The softmax-margin criterion, like log-likelihood, normalizes globally over all of the exponentially many possible labeled segmentations. The following zeroth-order semi-Markov dynamic program (Sarawagi et al., 2004) efficiently computes $Z$:

where $Z=z_{n}$, under the base case $z_{0}=1$. The cost function is easily incorporated because it factors in the same way as $\phi$.

The model’s prediction can be calculated using a similar dynamic programming algorithm with the following recurrence (and the usual “arg max” bookkeeping):

Our model formulation enforces only the no-overlap constraint; we expect it learn other SRL constraints from the data. We optimize using ADAM (Kingma and Ba, 2014). Models are trained a single thread on an NVIDIA Tesla K40 CPU. Convergence requires $15$ epochs. Hyperparameters are tuned based on performance on the held-out development set, with further implementation details given in §6.

Syntactic Features

Syntax has been important in many past models for semantic argument prediction (Punyakanok et al., 2008; Toutanova et al., 2008; Johansson and Nugues, 2008; FitzGerald et al., 2015, inter alia). The SegRNN-based model in §3 is syntax-free, but it is straightforward to incorporate features from a syntactic parse of the sentence as additional input to the model. We note that the computational cost of syntactic parsing—especially phrase-structure parsing—is significant, but it is important to test whether the SegRNN model can benefit from syntax.

We apply a state-of-the-art phrase-structure parser (RNNG; Dyer et al., 2016), extracting the features in Table 1 for each span. We then concatenate these features to the span representation (Equation 6) in our span scoring model. We found that 84% of gold-standard argument spans correspond to predicted constituents.

Dependency features.

We apply a state-of-the-art dependency parser (SyntaxNet; Andor et al., 2016), extracting the features in Table 2 from its output. The two word-level features are concatenated to the word vectors before they are fed into the token BiLSTM. The three span-level features are concatenated to the span representation (Equation 6). The out# features capture information similar to that used in prior work’s span-filtering heuristics. The out#=1 feature, for example, is an approximation of the is_phrase constituent feature. Since word-level representations include dependency head and label information, the path_lstm has access to that information for each dependency along the path as well.

Finally, note that these two variants of our model do not filter candidate spans, as done in past work. Instead, we allow the learner to flexibly consider syntactic features when scoring spans, potentially leading to a kind of “soft” filter.

Syntactic Scaffolding

A wide range of recent results in NLP have shown the benefit of multitask representation learning Caruana (1997), where the same embeddings of words are learned to minimize the loss functions of multiple tasks Luong et al. (2015); Chen et al. (2017); Peng et al. (2017). Here we consider a “scaffold” task—one we use only during learning, and whose output we are not especially interested in—in a multitask setup with our basic model (§3). The second task in our setup is learning to predict syntactic constituent spans. Since frame-semantic arguments are often also constituents, we hypothesize that learning which text spans are constituents might help us learn which spans could be arguments. Toward this end we use additional annotations from a separate training corpus that does not significantly overlap the FrameNet corpus: the Penn Treebank (PTB).There is no overlap between the full-text test data and PTB, however 86 sentences in the training and development data are also found in PTB. Our multi-task learning setting allows us to learn span embeddings that are shared between our frame-semantic parser and a model for predicting syntactic constituents.

Formally, we consider a segment $\langle i,j,r\rangle$ where $r\in\{0,1\}$ is a label with a corpus-specific definition. Spans in PTB starting at position $i$ and ending at position $j$ which are gold constituents get $r^{\ast}=1$, and others get $r^{\ast}=0$. Similarly, for FrameNet, we assign $r^{\ast}=1$ for every span in a sentence which has been annotated as a frame element for any frame, and $r^{\ast}=0$ otherwise.

Analogous to the scoring function under our basic model (§3), we define a new scoring function, $\psi$ for every segment $\langle i,j,r\rangle$:

Our scaffold loss function is essentially a binary logistic regression loss for each text span: $\text{loss}_{\text{scaffold}}(\langle i,j,r^{\ast}\rangle,\bm{x})=$

The joint multi-task loss for a single sentence is:

where $\delta<1$ is a hyperparameter used to de-emphasize the scaffold task, tuned on the development set. The first term does not apply to sentences in PTB, since we do not have frame-semantic annotations $\bm{s}^{\ast}$.

At prediction time (including test time), no syntactic prediction is necessary; the scaffold is removed.

Experiments

In this section, we provide details of the dataset and experimental setup for all four models: the basic SegRNN (§3), the phrase-structure and dependency syntactic feature additions (§4) and the syntactic scaffold (§5).

Our dataset contains sentences2,716 train sentences with 17,141 targets and 2,420 test sentences with 4,427 targets. from the full-text portion of FrameNet release 1.5 (September 2010). We use the same test set as Das and Smith (2011) to facilitate comparison with related work. We chose eight additional files at random as a held-out development set; the rest of the files in the full-text data are used for training. The FrameNet full-text data occassionally contains multiple annotations for the same target. We use only the first annotation for such examples, following FitzGerald et al. (2015).

We use SyntaxNet (Andor et al., 2016) for predicted part-of-speech tags and Universal dependencies, from a released pretrained model.https://github.com/tensorflow/models/tree/master/syntaxnet For phrase-structure parses, we use the RNNG parser (Dyer et al., 2016), trained on WSJ §2-21. We stochastically (with probability 0.1) replace words that only appear once in the training data with an unk token to acquire estimates for out-of-vocabulary words at test time.

For the syntactic scaffold, we used all 49,208 sentences from WSJ §00–24 of Penn Treebank.

2 Hyperparameters

We used single-layer LSTMs for sentence encoding, spans, targets, dependency and nonterminal paths, each with a hidden state of size 64. Pretrained GloVe Pennington et al. (2014) vectors of dimension 100 are used, trained on a corpus of 6 billion words; we do not update these during training. Learned embeddings of size 60, 4, 100, 64, 50, 8 and 16 are used for words, POS tags, frames, lexical units, frame-elements, dependency labels and nonterminals, respectively. For ADAM we set the initial learning rate to 0.0005, the moving average parameter to 0.01, the moving average variance to 0.9999, and the $\epsilon$ parameter (to prevent numerical instability) to $10^{-8}$; no learning rate decay is used. To prevent “exploding” gradients, we clip the 2-norm of the gradient Graves (2013) to 5 before each gradient update. These values were selected based on intuition and prior work; a more careful tuning of the above hyperparameters could be expected to improve performance.

The remaining hyperparameters were chosen based on their $F_{1}$ performance on the held-out development set. We selected the dropout rate Srivastava et al. (2014) of 0.05 from the set $\{0.01,0.05,0.1\}$. We selected the recall-oriented cost $\alpha=2$ from the set $\{1,2,5,10\}$. We selected the scaffold weight $\delta=0.17$ from the set $\{0.17,0.34,0.89\}$.

Our experiments were run using the DyNet library Neubig et al. (2017).https://github.com/clab/dynet

3 Self-Ensembling

To compensate for the variance resulting from different initializations, we use a self-ensembling approach. We train five models, differing only in their random initialization, and ensemble their local scores at test time. Specifically, we calculate the sum of the segment scores under each model ($\phi(s,\bm{x})$ in Eq. 7) to get the final ensembled segment score, which is then plugged into Eq. 13 to decode.

4 Evaluation

All systems are evaluated for precision, recall, and $F_{1}$, micro-averaged across test examples, following standard practice. We use the standard script provided by SemEval 2007 Baker et al. (2007), with a single modification provided by Kshirsagar et al. (2015) to optionally ignore the frame identification output. This allows us to evaluate for argument identification in isolation, which is the primary focus of this paper; for this setting we use gold frames (without rewarding them in $F_{1}$ evaluation). We also evaluate with predicted frames to illustrate our effect on end-to-end parsing performance; for this, we use the same predicted frames as FitzGerald et al. (2015), who retrained the frame identification model from Hermann et al. (2014) but with an updated dependency parser.

5 Baselines

SEMAFOR (Das et al., 2014) is a widely used system that identifies frame-semantic arguments using a linear model with hand-engineered features based on dependency parses. SEMAFOR also prunes out argument spans using syntactic heuristics and uses beam search, or optionally AD3, to decode while respecting constraints (Das et al., 2012). Kshirsagar et al. (2015) extended SEMAFOR through the use of exemplar FrameNet annotations, guide features from PropBank, and the FrameNet hierarchy.

In an extension to Täckström et al. (2015), FitzGerald et al. (2015) proposed a multi-task learning approach for frame-semantic parsing and PropBank SRL, using a feed-forward neural network to score candidate arguments. The input to the neural network is a set of hand-engineered features extracted from a dependency parse.

In a separate line of work, Framat Roth and Lapata (2015) adds features based on context and discourse to improve an SRL system Björkelund et al. (2010) adapted for frame-semantics, using a global model with reranking. Roth and Lapata (2016) and Roth (2017) extend this model by learning embeddings for dependency paths between targets and their arguments. We borrow their use of path embeddings as syntactic features, but we explicitly model argument spans using SegRNNs, without any reranking. More importantly, our scaffolding model does not rely on a syntactic parser.

6 Results

Table 3 shows the performance of five published baseline systems, along with our four new models (with and without ensembling). Surprisingly, the basic model (Open-SESAME) outperforms the original SEMAFOR parser (Das et al., 2014), and matches an improved version (Kshirsagar et al., 2015), without using any cues from syntax. We attribute this improvement to representation learning.

Perhaps less surprisingly, all three syntactic additions improve the performance of our basic model. The performances of phrase-structure features and dependency features are comparable. The syntactic scaffold performance is not far behind, and in fact beats the dependency features model after ensembling.

Self-ensembling markedly improves performance across all models, presumably because it reduces variance due to the non-convexity of the learning objective. Our best ensembled performance is tied with the state-of-the-art system by FitzGerald et al. (2015), which uses external semantic resources such as PropBank in addition to extensive syntactic features and self-ensembling. Our best scaffolding model is within 0.2% absolute $F_{1}$ of state-of-the-art, without any use of a syntactic parser or external semantic resources.

We also tested our recall-oriented softmax-margin loss (Eq. 8) against a plain log loss. Softmax-margin proved a good choice consistently across all our models (see Fig. 3).

Related Work

There has been much research on jointly modeling syntax and semantic roles, mostly on PropBank dependencies. Other work has used parallel annotations to jointly model syntax and semantics, as in the CoNLL 2008–9 shared tasks (Surdeanu et al., 2008; Hajič et al., 2009). Such methods are able to more directly model the connection between syntax and semantics, but they require syntactic and semantic annotations over the same corpora (Johansson and Nugues, 2008; Lluís and Màrquez, 2008; Titov et al., 2009; Roth and Woodsend, 2014; Lewis et al., 2015; Swayamdipta et al., 2016, inter alia). Our work also learns syntactic representations, but needs only partial syntax annotations (bracketing), and not necessarily on the same data as that annotated with frame semantics.

Latent syntax

Some work has treated syntax as a latent variable and marginalized it out (Naradowsky et al., 2012; Gormley et al., 2014), an approach that requires no syntactic supervision, even during training, making it especially suitable for low-resource settings. Collobert et al. (2011) use only syntactic boundaries for semantic role labeling; Zhou and Xu (2015) extend their approach by forgoing all syntax and using very deep neural nets. Kim et al. (2017) and Parikh et al. (2016) use different kinds of attention mechanism Bahdanau et al. (2014) to learn representations of sentences for natural language inference. To our knowledge, our basic model (§3) is the first non-syntactic frame-semantic parser.

Conclusion

We presented a softmax-margin semi-Markov model that uses representation learning to predict frame-semantic arguments. Our basic model achieves strong results without using any syntax. We add syntax through a traditional pipeline as well as a multi-task learning approach which uses a syntactic scaffold only at training time. Both approaches improve over the baseline, and achieve state-of-the-art performance, showing that syntax continues to be beneficial in frame-semantic parsing. We conclude that scaffolding is a cheaper alternative to syntactic features since it does not require syntactic parsing at train or at test time. Applying this technique to other tasks which rely on pipelining syntactic parsing is a promising avenue for future work. Our parser is open-source and available at: https://github.com/Noahs-ARK/open-sesame/.

Acknowledgments

We thank Adhiguna Kuncoro for help with RNNG, and Dipanjan Das and Michael Roth for providing their output and for their helpful communication. We also thank Hao Peng, George Mulcaire, Trang Tran, Kenton Lee, Luke Zettlemoyer, and ARK members for valuable feedback. This work was supported by DARPA grant FA8750-12-2-0342 funded under the DEFT program.

References

Appendix A Frame Identification

To complement our argument identification system, we also release a syntax-free frame identification system, which we describe here. We treat frame id as an independent multiclass classification task for each target. Given a sentence, a target, and its corresponding lexical unit, the task is to identify the frame the target evokes. Hermann et al. (2014) and FitzGerald et al. (2015) use gold targets and lexical units; for a fair comparison we do the same.

At each word position $q$, we give as input to a token biLSTM (f-tok) an input vector $\mathbf{u}_{q}=[\mathbf{d}_{q};\mathbf{e}_{q};\mathbf{o}_{q}]$, where $\mathbf{d}_{q}$ is a learned embedding of the word type, $\mathbf{e}_{q}$ is a fixed pre-trained embedding of the word type, and $\mathbf{o}_{q}$ is a learned embedding of the part-of-speech tag. This yields a hidden state vector $\mathbf{h}^{\text{f-tok}}_{q}$ at the $q$th token, corresponding to a contextualized representation of the word:

To represent the target in context, we use $\mathbf{h}^{\text{f-tok}}$ over the target span $t$, as well as the neighboring context window of size 1, as input to a forward LSTM:

where the scalar $w^{f}_{3}$ and the vector $\mathbf{w}^{f}_{4}$ are model parameters associated with the frame $f$. The probability under our model is given by:

Negative log likelihood is minimized during training, using ADAM (Kingma and Ba, 2014). A single pass through the sentence is sufficient to predict frames for all targets.

To compensate for the variance resulting from different initializations, we use a five model self-ensemble (as in §6.3) to aggregate frame scores in Eq. 19. Pretrained GloVe Pennington et al. (2014) vectors of dimension 100 are used. For tuning hyperparameters, we use the same methods as described in §6.2.

A.2 Results

The performance of our model is shown in Table 4. Our model significantly outperforms SEMAFOR, which uses a variety of syntactic features. Hermann et al. (2014) reuse most of the features from SEMAFOR, as well as WSABIE embeddings Weston et al. (2011) that also make use of syntax. FitzGerald et al. (2015) reimplement their model and report slightly better scores (possibly due to differences in parameter initialization or syntactic parses used). Our performance is similar to Hartmann et al. (2017), who focus on improving out of domain frame identification performance using a large external database. We use no external resources.

Finally, we show the performance of our end-to-end system with both frame and argument identification in Table 5. As expected, it is lower than the results in Table 3, illustrating the importance of frame identification in a frame-semantic parsing pipeline.