| { |
| "paper_id": "P17-1027", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T08:17:15.964550Z" |
| }, |
| "title": "A Full Non-Monotonic Transition System for Unrestricted Non-Projective Parsing", |
| "authors": [ |
| { |
| "first": "Daniel", |
| "middle": [], |
| "last": "Fern\u00e1ndez-Gonz\u00e1lez", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "LyS Research Group", |
| "institution": "Universidade da Coru\u00f1a FASTPARSE Lab", |
| "location": { |
| "postCode": "15071 A", |
| "settlement": "s/n, Coru\u00f1a", |
| "country": "Spain" |
| } |
| }, |
| "email": "" |
| }, |
| { |
| "first": "Carlos", |
| "middle": [], |
| "last": "G\u00f3mez-Rodr\u00edguez", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "LyS Research Group", |
| "institution": "Universidade da Coru\u00f1a FASTPARSE Lab", |
| "location": { |
| "postCode": "15071 A", |
| "settlement": "s/n, Coru\u00f1a", |
| "country": "Spain" |
| } |
| }, |
| "email": "carlos.gomez@udc.es" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "Restricted non-monotonicity has been shown beneficial for the projective arceager dependency parser in previous research, as posterior decisions can repair mistakes made in previous states due to the lack of information. In this paper, we propose a novel, fully non-monotonic transition system based on the non-projective Covington algorithm. As a non-monotonic system requires exploration of erroneous actions during the training process, we develop several non-monotonic variants of the recently defined dynamic oracle for the Covington parser, based on tight approximations of the loss. Experiments on datasets from the CoNLL-X and CoNLL-XI shared tasks show that a non-monotonic dynamic oracle outperforms the monotonic version in the majority of languages.", |
| "pdf_parse": { |
| "paper_id": "P17-1027", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "Restricted non-monotonicity has been shown beneficial for the projective arceager dependency parser in previous research, as posterior decisions can repair mistakes made in previous states due to the lack of information. In this paper, we propose a novel, fully non-monotonic transition system based on the non-projective Covington algorithm. As a non-monotonic system requires exploration of erroneous actions during the training process, we develop several non-monotonic variants of the recently defined dynamic oracle for the Covington parser, based on tight approximations of the loss. Experiments on datasets from the CoNLL-X and CoNLL-XI shared tasks show that a non-monotonic dynamic oracle outperforms the monotonic version in the majority of languages.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "Greedy transition-based dependency parsers are widely used in different NLP tasks due to their speed and efficiency. They parse a sentence from left to right by greedily choosing the highestscoring transition to go from the current parser configuration or state to the next. The resulting sequence of transitions incrementally builds a parse for the input sentence. The scoring of the transitions is provided by a statistical model, previously trained to approximate an oracle, a function that selects the needed transitions to parse a gold tree.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Unfortunately, the greedy nature that grants these parsers their efficiency also represents their main limitation. show that greedy transition-based parsers lose accuracy to error propagation: a transition erroneously chosen by the greedy parser can place it in an incorrect and unknown configuration, causing more mistakes in the rest of the transition sequence. Training with a dynamic oracle (Goldberg and Nivre, 2012) improves robustness in these situations, but in a monotonic transition system, erroneous decisions made in the past are permanent, even when the availability of further information in later states might be useful to correct them. Honnibal et al. (2013) show that allowing some degree of non-monotonicity, by using a limited set of non-monotonic actions that can repair past mistakes and replace previously-built arcs, can increase the accuracy of a transition-based parser. In particular, they present a modified arc-eager transition system where the Left-Arc and Reduce transitions are non-monotonic: the former is used to repair invalid attachments made in previous states by replacing them with a leftward arc, and the latter allows the parser to link two words with a rightward arc that were previously left unattached due to an erroneous decision. Since the Right-Arc transition is still monotonic and leftward arcs can never be repaired because their dependent is removed from the stack by the arc-eager parser and rendered inaccessible, this approach can only repair certain kinds of mistakes: namely, it can fix erroneous rightward arcs by replacing them with a leftward arc, and connect a limited set of unattached words with rightward arcs. In addition, they argue that non-monotonicity in the training oracle can be harmful for the final accuracy and, therefore, they suggest to apply it only as a fallback component for a monotonic oracle, which is given priority over the non-monotonic one. Thus, this strategy will follow the path dictated by the monotonic oracle the majority of the time. Honnibal and Johnson (2015) present an extension of this transition system with an Unshift transition allowing it some extra flexibility to correct past errors. However, the restriction that only rightward arcs can be deleted, and only by replacing them with leftward arcs, is still in place. Furthermore, both versions of the algorithm are limited to projective trees.", |
| "cite_spans": [ |
| { |
| "start": 395, |
| "end": 421, |
| "text": "(Goldberg and Nivre, 2012)", |
| "ref_id": "BIBREF4" |
| }, |
| { |
| "start": 652, |
| "end": 674, |
| "text": "Honnibal et al. (2013)", |
| "ref_id": "BIBREF9" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "In this paper, we propose a non-monotonic transition system based on the non-projective Covington parser, together with a dynamic oracle to train it with erroneous examples that will need to be repaired. Unlike the system developed in (Honnibal et al., 2013; Honnibal and Johnson, 2015) , we work with full non-monotonicity. This has a twofold meaning: (1) our approach can repair previous erroneous attachments regardless of their original direction, and it can replace them either with a rightward or leftward arc as both arc transitions are non-monotonic; 1 and (2) we use exclusively a non-monotonic oracle, without the interferences of monotonic decisions. These modifications are feasible because the non-projective Covington transition system is less rigid than the arc-eager algorithm, as words are never deleted from the parser's data structures and can always be revisited, making it a better option to exploit the full potencial of non-monotonicity. To our knowledge, the presented system is the first nonmonotonic parser that can produce non-projective dependency analyses. Another novel aspect is that our dynamic oracle is approximate, i.e., based on efficiently-computable approximations of the loss due to the complexity of calculating its actual value in a non-monotonic and non-projective scenario. However, this is not a problem in practice: experimental results show how our parser and oracle can use non-monotonic actions to repair erroneous attachments, outperforming the monotonic version developed by G\u00f3mez-Rodr\u00edguez and Fern\u00e1ndez-Gonz\u00e1lez (2015) in a large majority of the datasets tested.", |
| "cite_spans": [ |
| { |
| "start": 235, |
| "end": 258, |
| "text": "(Honnibal et al., 2013;", |
| "ref_id": "BIBREF9" |
| }, |
| { |
| "start": 259, |
| "end": 286, |
| "text": "Honnibal and Johnson, 2015)", |
| "ref_id": "BIBREF10" |
| }, |
| { |
| "start": 1525, |
| "end": 1570, |
| "text": "G\u00f3mez-Rodr\u00edguez and Fern\u00e1ndez-Gonz\u00e1lez (2015)", |
| "ref_id": "BIBREF6" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The non-projective Covington parser was originally defined by Covington (2001) , and then recast by Nivre (2008) under the transition-based parsing framework.", |
| "cite_spans": [ |
| { |
| "start": 62, |
| "end": 78, |
| "text": "Covington (2001)", |
| "ref_id": "BIBREF2" |
| }, |
| { |
| "start": 100, |
| "end": 112, |
| "text": "Nivre (2008)", |
| "ref_id": "BIBREF15" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "1 The only restriction is that parsing must still proceed in left-to-right order. For this reason, a leftward arc cannot be repaired with a rightward arc, because this would imply going back in the sentence. The other three combinations (replacing leftward with leftward, rightward with leftward or rightward with rightward arcs) are possible.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "The transition system that defines this parser is as follows: each parser configuration is of the form c = \u03bb 1 , \u03bb 2 , B, A , such that \u03bb 1 and \u03bb 2 are lists of partially processed words, B is another list (called the buffer) containing currently unprocessed words, and A is the set of dependencies that have been built so far. Suppose that our input is a string w 1 \u2022 \u2022 \u2022 w n , whose word occurrences will be identified with their indices 1 \u2022 \u2022 \u2022 n for simplicity. Then, the parser will start at an initial configuration c s (w 1 . . . These transitions implement the same logic as the double nested loop traversing word pairs in the original formulation by Covington (2001) . When the parser's configuration is \u03bb 1 |i, \u03bb 2 , j|B, A , we say that it is considering the focus words i and j, located at the end of the first list and at the beginning of the buffer. At that point, the parser must decide whether these two words should be linked with a leftward arc i \u2190 j (Left-Arc transition), a rightward arc i \u2192 j (Right-Arc transition), or not linked at all (No-Arc transition). However, the two transitions that create arcs will be disallowed in configurations where this would cause a violation of the single-head constraint (a node can have at most one incoming arc) or the acyclicity constraint (the dependency graph cannot have cycles). After applying any of these three transitions, i is moved to the second list to make i \u2212 1 and j the focus words for the next step. As an alternative, we can instead choose to execute a Shift transition which lets the parser read a new input word, placing the focus on j and j + 1.", |
| "cite_spans": [ |
| { |
| "start": 659, |
| "end": 675, |
| "text": "Covington (2001)", |
| "ref_id": "BIBREF2" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "The resulting parser can generate any possible dependency tree for the input, including arbitrary non-projective trees. While it runs in quadratic worst-case time, in theory worse than lineartime transition-based parsers (e.g. (Nivre, 2003; G\u00f3mez-Rodr\u00edguez and Nivre, 2013) ), it has been shown to outspeed linear algorithms in practice, thanks to feature extraction optimizations that cannot be implemented in other parsers (Volokh and Neumann, 2012) . In fact, one of the fastest dependency parsers ever reported uses this algorithm Shift:", |
| "cite_spans": [ |
| { |
| "start": 227, |
| "end": 240, |
| "text": "(Nivre, 2003;", |
| "ref_id": "BIBREF14" |
| }, |
| { |
| "start": 241, |
| "end": 273, |
| "text": "G\u00f3mez-Rodr\u00edguez and Nivre, 2013)", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 425, |
| "end": 451, |
| "text": "(Volokh and Neumann, 2012)", |
| "ref_id": "BIBREF20" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "\u03bb1, \u03bb2, j|B, A \u21d2 \u03bb1 \u2022 \u03bb2|j, [], B, A No-Arc: \u03bb1|i, \u03bb2, B, A \u21d2 \u03bb1, i|\u03bb2, B, A Left-Arc:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "\u03bb1|i, \u03bb2, j|B, A \u21d2 \u03bb1, i|\u03bb2, j|B, A \u222a {j \u2192 i} only if k | k \u2192 i \u2208 A (single-head) and i \u2192 * j \u2208 A (acyclicity).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "Right-Arc: \u03bb1|i, \u03bb2, j|B, A \u21d2 \u03bb1, i|\u03bb2, j|B, A \u222a {i \u2192 j} only if k | k \u2192 j \u2208 A (single-head) and j \u2192 * i \u2208 A (acyclicity).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "Figure 1: Transitions of the monotonic Covington non-projective dependency parser. The notation i \u2192 * j \u2208 A means that there is a (possibly empty) directed path from i to j in A. (Volokh, 2013) .", |
| "cite_spans": [ |
| { |
| "start": 179, |
| "end": 193, |
| "text": "(Volokh, 2013)", |
| "ref_id": "BIBREF19" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Projective Covington Transition System", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "A dynamic oracle is a function that maps a configuration c and a gold tree t G to the set of transitions that can be applied in c and lead to some parse tree t minimizing the Hamming loss with respect to t G (the amount of nodes whose head is different in t and t G ). Following Goldberg and Nivre (2013) , we say that an arc set A is reachable from configuration c, and we write c A, if there is some (possibly empty) path of transitions from c to some configuration c = \u03bb 1 , \u03bb 2 , B, A , with A \u2286 A . Then, we can define the loss of configuration c as", |
| "cite_spans": [ |
| { |
| "start": 279, |
| "end": 304, |
| "text": "Goldberg and Nivre (2013)", |
| "ref_id": "BIBREF5" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "(c) = min t|c t L(t, t G ),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "and therefore, a correct dynamic oracle will return the set of transitions", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "o d (c, t G ) = {\u03c4 | (c) \u2212 (\u03c4 (c)) = 0},", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "i.e., the set of transitions that do not increase configuration loss, and thus lead to the best parse (in terms of loss) reachable from c. Hence, implementing a dynamic oracle reduces to computing the loss (c) for each configuration c. Goldberg and Nivre (2013) show a straightforward method to calculate loss for parsers that are arc-decomposable, i.e., those where every arc set A that can be part of a well-formed parse verifies that if c (i \u2192 j) for every i \u2192 j \u2208 A (i.e., each of the individual arcs of A is reachable from a given configuration c), then c A (i.e., the set A as a whole is reachable from c). If this holds, then the loss of a configuration c equals the number of gold arcs that are not individually reachable from c, which is easy to compute in most parsers. G\u00f3mez-Rodr\u00edguez and Fern\u00e1ndez-Gonz\u00e1lez (2015) show that the non-projective Covington parser is not arc-decomposable because sets of individually reachable arcs may form cycles together with already-built arcs, preventing them from being jointly reachable due to the acyclicity constraint. In spite of this, they prove that a dynamic oracle for the Covington parser can be efficiently built by counting individually unreachable arcs, and correcting for the presence of such cycles. Concretely, the loss is computed as:", |
| "cite_spans": [ |
| { |
| "start": 236, |
| "end": 261, |
| "text": "Goldberg and Nivre (2013)", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 780, |
| "end": 825, |
| "text": "G\u00f3mez-Rodr\u00edguez and Fern\u00e1ndez-Gonz\u00e1lez (2015)", |
| "ref_id": "BIBREF6" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "(c) = |U(c, t G )| + n c (A \u222a I(c, t G )) where I(c, t G ) = {x \u2192 y \u2208 t G | c (x \u2192 y)} is the set of individually reachable arcs of t G from configuration c; U(c, t G ) is the set of indi- vidually unreachable arcs of t G from c, com- puted as t G \\I(c, t G )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "; and n c (G) denotes the number of cycles in a graph G.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "Therefore, to calculate the loss of a configuration c, we only need to compute the two terms |U(c, t G )| and n c (A \u222a I(c, t G )). To calculate the first term, given a configuration c with focus words i and j (i.e., c = \u03bb 1 |i, \u03bb 2 , j|B, A ), an arc x \u2192 y will be in U(c, t G ) if it is not in A, and at least one of the following holds:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "\u2022 j > max(x, y), (i.e., we have read too far in the string and can no longer get max(x, y) as right focus word),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "\u2022 j = max(x, y) \u2227 i < min(x, y), (i.e., we", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "have max(x, y) as the right focus word but the left focus word has already moved left past min(x, y), and we cannot go back), \u2022 there is some z = 0, z = x such that z \u2192 y \u2208 A, (i.e., we cannot create x \u2192 y because it would violate the single-head constraint), \u2022 x and y are on the same weakly connected component of A (i.e., we cannot create x \u2192 y due to the acyclicity constraint). The second term of the loss, n c (A \u222a I(c, t G )), can be computed by first obtaining I(c, t G ) as t G \\ U(c, t G ). Since the graph I(c, t G ) has indegree 1, the algorithm by Tarjan (1972) can then be used to find and count the cycles in O(n) time.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "Algorithm 1 Computation of the loss of a configuration in the monotonic oracle.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "1: function LOSS(c = \u03bb1|i, \u03bb2, j|B, A , tG) 2: U \u2190 \u2205 Variable U is for U(c, tG) 3: for each x \u2192 y \u2208 (tG \\ A) do 4: left \u2190 min(x, y) 5: right \u2190 max(x, y) 6: if j > right \u2228 7: (j = right \u2227 i < left) \u2228 8: (\u2203z > 0, z = x : z \u2192 y \u2208 A) \u2228 9:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "WEAKLYCONNECTED(A, x, y) then 10:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "U \u2190 u \u222a {x \u2192 y} 11: I \u2190 tG \\ U Variable I is for I(c, tG) 12: return |U | + COUNTCYCLES(A \u222a I )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "Algorithm 1 shows the resulting loss calculation algorithm, where COUNTCYCLES is a function that counts the number of cycles in the given graph and WEAKLYCONNECTED returns whether two given nodes are weakly connected in A.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Monotonic Dynamic Oracle", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "We now define a non-monotonic variant of the Covington non-projective parser. To do so, we allow the Right-Arc and Left-Arc transitions to create arcs between any pair of nodes without restriction. If the node attached as dependent already had a previous head, the existing attachment is discarded in favor of the new one. This allows the parser to correct erroneous attachments made in the past by assigning new heads, while still enforcing the single-head constraint, as only the most recent head assigned to each node is kept.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Transition System for the Covington Non-Projective Parser", |
| "sec_num": "3" |
| }, |
| { |
| "text": "To enforce acyclicity, one possibility would be to keep the logic of the monotonic algorithm, forbidding the creation of arcs that would create cycles. However, this greatly complicates the definition of the set of individually unreachable arcs, which is needed to compute the loss bounds that will be used by the dynamic oracle. This is because a gold arc x \u2192 y may superficially seem unreachable due to forming a cycle together with arcs in A, but it might in fact be reachable if there is some transition sequence that first breaks the cycle using non-monotonic transitions to remove arcs from A, to then create x \u2192 y. We do not know of a way to characterize the conditions under which such a transition sequence exists, and thus cannot estimate the loss efficiently.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Transition System for the Covington Non-Projective Parser", |
| "sec_num": "3" |
| }, |
| { |
| "text": "Instead, we enforce the acyclicity constraint in a similar way to the single-head constraint: Right-Arc and Left-Arc transitions are always allowed, even if the prospective arc would create a cycle in A. However, if the creation of a new arc x \u2192 y generates a cycle in A, we immediately remove the arc of the form z \u2192 x from A (which trivially exists, and is unique due to the singlehead constraint). This not only enforces the acyclicity constraint while keeping the computation of U(c, t G ) simple and efficient, but also produces a straightforward, coherent algorithm (arc transitions are always allowed, and both constraints are enforced by deleting a previous arc) and allows us to exploit non-monotonicity to the maximum (we can not only recover from assigning a node the wrong head, but also from situations where previous errors together with the acyclicity constraint prevent us from building a gold arc, keeping with the principle that later decisions override earlier ones).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Transition System for the Covington Non-Projective Parser", |
| "sec_num": "3" |
| }, |
| { |
| "text": "In Figure 2 , we can see the resulting nonmonotonic transition system for the non-projective Covington algorithm, where, unlike the monotonic version, all transitions are allowed at each configuration, and the single-head and acyclicity constraints are kept in A by removing offending arcs.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 3, |
| "end": 11, |
| "text": "Figure 2", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Non-Monotonic Transition System for the Covington Non-Projective Parser", |
| "sec_num": "3" |
| }, |
| { |
| "text": "To successfully train a non-monotonic system, we need a dynamic oracle with error exploration, so that the parser will be put in erroneous states and need to apply non-monotonic transitions in order to repair them. To achieve that, we modify the dynamic oracle defined by G\u00f3mez-Rodr\u00edguez and Fern\u00e1ndez-Gonz\u00e1lez (2015) so that it can deal with non-monotonicity. Our modification is an approximate dynamic oracle: due to the extra flexibility added to the algorithm by non-monotonicity, we do not know of an efficient way of obtaining an exact calculation of the loss of a given configuration. Instead, we use upper or lower bounds on the loss, which we empirically show to be very tight (less that 1% relative error with respect to the real loss) and are sufficient for the algorithm to provide better accuracy than the exact monotonic oracle. First of all, we adapt the computation of the set of individually unreachable arcs U(c, t G ) to the new algorithm. In particular, if c has focus words i and j (i.e., c = \u03bb 1 |i, \u03bb 2 , j|B, A ), then an arc x \u2192 y is in U(c, t G ) if it is not in A, and at least one of the following holds:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "\u2022 j > max(x, y), (i.e., we have read too far in the string and can no longer get max(x, y) as Shift: Figure 2 : Transitions of the non-monotonic Covington non-projective dependency parser. The notation i \u2192 * j \u2208 A means that there is a (possibly empty) directed path from i to j in A.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 101, |
| "end": 109, |
| "text": "Figure 2", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "\u03bb1, \u03bb2, j|B, A \u21d2 \u03bb1 \u2022 \u03bb2|j, [], B, A No-Arc: \u03bb1|i, \u03bb2, B, A \u21d2 \u03bb1, i|\u03bb2, B, A Left-Arc: \u03bb1|i, \u03bb2, j|B, A \u21d2 \u03bb1, i|\u03bb2, j|B, (A \u222a {j \u2192 i}) \\{x \u2192 i \u2208 A} \\ {k \u2192 j \u2208 A | i \u2192 * k \u2208 A} Right-Arc: \u03bb1|i, \u03bb2, j|B, A \u21d2 \u03bb1, i|\u03bb2, j|B, A \u222a {i \u2192 j} \\{x \u2192 j \u2208 A} \\ {k \u2192 i \u2208 A | j \u2192 * k \u2208 A}", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "right focus word),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "\u2022 j = max(x, y) \u2227 i < min(x, y) (i.e., we", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "have max(x, y) as the right focus word but the left focus word has already moved left past min(x, y), and we cannot move it back). Note that, since the head of a node can change during the parsing process and arcs that produce cycles in A can be built, the two last conditions present in the monotonic scenario for computing U(c, t G ) are not needed when we use nonmonotonicity and, as a consequence, the set of individually reachable arcs I(c, t G ) is larger: due to the greater flexibility provided by nonmonotonicity, we can reach arcs that would be unreachable for the monotonic version.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "Since arcs that are in this new U(c, t G ) are unreachable even by the non-monotonic parser, |U(c, t G )| is trivially a lower bound of the loss (c). It is worth noting that there always exists at least one transition sequence that builds every arc in I(c, t G ) at some point (although not all of them necessarily appear in the final tree, due to non-monotonicity). This can be easily shown based on the fact that the non-monotonic parser does not forbid transitions at any configuration. Thanks to this, we can can generate one such sequence by just applying the original Covington (2001) criteria (choose an arc transition whenever the focus words are linked in I(c, t G ), and otherwise Shift or No-Arc depending on whether the left focus word is the first word in the sentence or not), although this sequence is not necessarily optimal in terms of loss. In such a transition sequence, the gold arcs that are missed are (1) those in U(c, t G ), and (2) those that are removed by the cycle-breaking in Left-Arc and Right-Arc transitions. In practice configurations where (2) is needed are uncommon, so this lower bound is a very close approximation of the real loss, as will be seen empirically below.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "This reasoning also helps us calculate an up-per bound of the loss: in a transition sequence as described, if we only build the arcs in I(c, t G ) and none else, the amount of arcs removed by breaking cycles (2) cannot be larger than the number of cycles in A \u222a I(c, t G ). This means that", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "|U(c, t G )|+n c (A\u222aI(c, t G ))", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "is an upper bound of the loss (c). Note that, contrary to the monotonic case, this expression does not always give us the exact loss, for several reasons: firstly, A \u222a I(c, t G ) can have non-disjoint cycles (a node may have different heads in A and I since attachments are not permanent, contrary to the monotonic version) and thus removing a single arc may break more than one cycle; secondly, the removed arc can be a non-gold arc of A and therefore not incur loss; and thirdly, there may exist alternative transition sequences where a cycle in A \u222a I(c, t G ) is broken early by non-monotonic configurations that change the head of a wrongly-attached node in A to a different (and also wrong) head, 3 removing the cycle before the cycle-breaking mechanism needs to come into play without incurring in extra errors. Characterizing the situations where such an alternative exists is the main difficulty for an exact calculation of the loss. However, it is possible to obtain a closer upper bound to the real loss if we consider the following: for each cycle in A \u222a I(c, t G ) that will be broken by the transition sequence described above, we can determine exactly which is the arc removed by cycle-breaking (if x \u2192 y is the arc that will close the cycle according to the Covington arc-building order, then the affected arc is the one of the form z \u2192 x). The cycle can only cause the loss of a gold arc if that arc z \u2192 x is gold, which can be trivially checked. Hence, if we call cycles where that holds problematic cycles, then the expression Table 1 : Average value of the different bounds and the loss, and of the relative differences from each bound to the loss, on CoNLL-XI (first block) and CoNLL-X (second block) datasets during 100,000 transitions. For each language, we show in boldface the average value and relative difference of the bound that is closer to the loss.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 1545, |
| "end": 1552, |
| "text": "Table 1", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "|U(c, t G )| + n pc (A \u222a I(c, t G )), where \"pc\" stands for problematic cycles, is a closer upper bound to the loss (c) and the following holds:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "|U(c, t G )| \u2264 (c) \u2264 |U(c, t G )|+n pc (A\u222aI(c, t G )) \u2264 |U(c, t G )| + n c (A \u222a I(c, t G ))", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "As mentioned before, unlike the monotonic approach, a node can have a different head in A than in I(c, t G ) and, as a consequence, the resulting graph A \u222a I(c, t G ) has maximum in-degree 2 rather than 1, and there can be overlapping cycles. Therefore, the computation of the non-monotonic terms n c (A \u222a I(c, t G )) and n pc (A \u222a I(c, t G )) requires an algorithm such as the one by Johnson (1975) to find all elementary cycles in a directed graph. This runs in O((n + e)(c + 1)), where n is the number of vertices, e is the number of edges and c is the number of elementary cycles in the graph. This implies that the calculation of the two non-monotonic upper bounds is less efficient than the linear loss computation in the monotonic scenario. However, a non-monotonic algorithm that uses the lower bound as loss expression is the fastest option (even faster than the monotonic approach) as the oracle does not need to compute cycles at all, speeding up the training process.", |
| "cite_spans": [ |
| { |
| "start": 385, |
| "end": 399, |
| "text": "Johnson (1975)", |
| "ref_id": "BIBREF11" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "Algorithm 2 shows the non-monotonic variant of Algorithm 1, where COUNTRELEVANT-CYCLES is a function that counts the number of cycles or problematic cycles in the given graph, Algorithm 2 Computation of the approximate loss of a non-monotonic configuration.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "1: function LOSS(c = \u03bb1|i, \u03bb2, j|B, A , tG) 2:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "U \u2190 \u2205 Variable U is for U(c, tG) 3: for each x \u2192 y \u2208 (tG \\ A) do 4: left \u2190 min(x, y) 5: right \u2190 max(x, y) 6:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "if j > right \u2228 7:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "(j = right \u2227 i < left) then 8:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "U \u2190 u \u222a {x \u2192 y} 9:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "I \u2190 tG \\ U Variable I is for I(c, tG) 10:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "return |U | + COUNTRELEVANTCYCLES(A \u222a I )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "depending on the upper bound implemented, and will return 0 in case we use the lower bound.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Non-Monotonic Approximate Dynamic Oracle", |
| "sec_num": "4" |
| }, |
| { |
| "text": "To determine how close the lower bound |U(c, t G )| and the upper bounds", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "|U(c, t G )| + n pc (A\u222aI(c, t G )) and |U(c, t G )|+n c (A\u222aI(c, t G ))", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "are to the actual loss in practical scenarios, we use exhaustive search to calculate the real loss of a given configuration, to then compare it with the bounds. This is feasible because the lower and upper bounds allow us to prune the search space: if an upper and a lower bound coincide for a configuration we already know the loss and need not keep searching, and if we can branch to two configurations such that the lower bound of one is greater or equal than an upper bound of the other, we can discard the former as it will never lead to smaller loss than the latter. Therefore, this ex- . . those to the right of R 0 . X ih means the head of X i , X ih2 the grandparent, X il and X il the farthest and closest left dependents, and X ir and X ir the farthest and closest right dependents, respectively. CL and CR are the first and last words between L 0 and R 0 whose head is not in the interval [L 0 , R 0 ]. Finally, w stands for word form; p for PoS tag; l for dependency label; d is the distance between L 0 and haustive search with pruning guarantees to find the exact loss. Due to the time complexity of this process, we undertake the analysis of only the first 100,000 transitions on each dataset of the nineteen languages available from CoNLL-X and CoNLL-XI shared tasks (Buchholz and Marsi, 2006; . In Table 1 , we present the average values for the lower bound, both upper bounds and the loss, as well as the relative differences from each bound to the real loss. After those experiments, we conclude that the lower and the closer upper bounds are a tight approximation of the loss, with both bounds incurring relative errors below 0.8% in all datasets. If we compare them, the real loss is closer to the upper bound |U(c, t G )| + n pc (A \u222a I(c, t G )) in the majority of datasets (12 out of 18 languages, excluding Japanese where both bounds were exactly equal to the real loss in the whole sample of configurations). This means that the term n pc (A \u222a I(c, t G )) provides a close approximation of the gold arcs missed by the presence of cycles in A. Regarding the upper bound |U(c, t", |
| "cite_spans": [ |
| { |
| "start": 1284, |
| "end": 1310, |
| "text": "(Buchholz and Marsi, 2006;", |
| "ref_id": "BIBREF0" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 1316, |
| "end": 1323, |
| "text": "Table 1", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "Unigrams L0w; L0p; L0wp; L0l; L 0h w; L 0h p; L 0h l; L 0l w; L 0l p; L 0l l; L 0r w; L 0r p; L 0r l; L 0h2 w; L 0h2 p; L 0h2 l; L 0l w; L 0l p; L", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "R 0 ; v l , v", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "G )| + n c (A \u222a I(c, t G )),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "it presents a more variable relative error, ranging from 0.1% to 4.0%.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "Thus, although we do not know an algorithm to obtain the exact loss which is fast enough to be practical, any of the three studied loss bounds can be used to obtain a feasible approximate dynamic oracle with full non-monotonicity.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation of the Loss Bounds", |
| "sec_num": "5" |
| }, |
| { |
| "text": "To prove the usefulness of our approach, we implement the static, dynamic monotonic and nonmonotonic oracles for the non-projective Covington algorithm and compare their accuracies on nine datasets 4 from the CoNLL-X shared task (Buchholz and Marsi, 2006) and all datasets from the CoNLL-XI shared task . For the non-monotonic algorithm, we test the three different loss expressions defined in the previous section. We train an averaged perceptron model for 15 iterations and use the same feature templates for all languages 5 which are listed in detail in Table 2 .", |
| "cite_spans": [ |
| { |
| "start": 229, |
| "end": 255, |
| "text": "(Buchholz and Marsi, 2006)", |
| "ref_id": "BIBREF0" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 557, |
| "end": 564, |
| "text": "Table 2", |
| "ref_id": "TABREF2" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Experiments", |
| "sec_num": "6" |
| }, |
| { |
| "text": "The accuracies obtained by the non-projective Covington parser with the three available oracles are presented in Table 3 , in terms of Unlabeled (UAS) and Labeled Attachment Score (LAS). For the non-monotonic dynamic oracle, three variants are shown, one for each loss expression implemented. As we can see, the novel non-monotonic oracle improves over the accuracy of the monotonic version on 14 out of 19 languages (0.32 in UAS on average) with the best loss calculation being |U(c, t G )| + n c (A \u222a I(c, t G )), where 6 of these improvements are statistically significant at the .05 level (Yeh, 2000) . The other two loss calculation methods also achieve good results, outperforming the monotonic algorithm on 12 out of 19 datasets tested.", |
| "cite_spans": [ |
| { |
| "start": 593, |
| "end": 604, |
| "text": "(Yeh, 2000)", |
| "ref_id": "BIBREF21" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 113, |
| "end": 120, |
| "text": "Table 3", |
| "ref_id": "TABREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.1" |
| }, |
| { |
| "text": "The loss expression |U(c, t G )| + n c (A \u222a I(c, t G )) obtains greater accuracy on average than the other two loss expressions, including the more adjusted upper bound that is provably closer to the real loss. This could be explained by the fact that identifying problematic cycles is a difficult task to learn for the parser, and for this reason a more straightforward approach, which tries to avoid all kinds of cycles (regardless of whether they will cost gold arcs or not), can perform better. This also leads us to hypothesize that, even if it were feasible to build an oracle with the exact loss, it would not provide practical improvements over these approximate oracles; as it appears difficult for a statistical model to learn the situations where replacing a wrong arc with another indirectly helps due to breaking prospective cycles.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.1" |
| }, |
| { |
| "text": "It is also worth mentioning that the nonmonotonic dynamic oracle with the best loss expression accomplishes an average improvement over the static version (1.26 UAS) greater than that obtained by the monotonic oracle (0.98 UAS), resulting in 13 statistically significant improvements achieved by the non-monotonic variant over the static oracle in comparison to the 12 obtained by the monotonic system. Finally, note that, despite this remarkable performance, the non-monotonic version (regardless of the loss expression implemented) has an inexplicable drop in accuracy in Basque in comparison to the other two oracles.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.1" |
| }, |
| { |
| "text": "In order to provide a broader contextualization of our approach, Table 4 presents a comparison of the average accuracy and parsing speed obtained by some well-known transition-based systems with dynamic oracles. Concretely, we include in this comparison both monotonic (Goldberg and Nivre, 2012) and non-monotonic (Honnibal et al., 2013) versions of the arc-eager parser, as well as the original monotonic Covington system (G\u00f3mez-Rodr\u00edguez and Fern\u00e1ndez-Gonz\u00e1lez, 2015) . The three of them were ran with our own implementation so the comparison is homogeneous. We also report the published accuracy of the non-projective Attardi algorithm (G\u00f3mez-Rodr\u00edguez et al., 2014) on the nineteen datasets used in our experiments. From Table 4 we can see that our approach achieves the best average UAS score, but is slightly slower at parsing time than the monotonic Covington algorithm. This can be explained by the fact that the non-monotonic parser has to take into consideration the whole set of transitions at each configuration (since all are allowed), while the monotonic parser only needs to evaluate a limited set of transitions in some con- figurations, speeding up the parsing process.", |
| "cite_spans": [ |
| { |
| "start": 314, |
| "end": 337, |
| "text": "(Honnibal et al., 2013)", |
| "ref_id": "BIBREF9" |
| }, |
| { |
| "start": 423, |
| "end": 469, |
| "text": "(G\u00f3mez-Rodr\u00edguez and Fern\u00e1ndez-Gonz\u00e1lez, 2015)", |
| "ref_id": "BIBREF6" |
| }, |
| { |
| "start": 639, |
| "end": 669, |
| "text": "(G\u00f3mez-Rodr\u00edguez et al., 2014)", |
| "ref_id": "BIBREF8" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 65, |
| "end": 72, |
| "text": "Table 4", |
| "ref_id": "TABREF6" |
| }, |
| { |
| "start": 725, |
| "end": 732, |
| "text": "Table 4", |
| "ref_id": "TABREF6" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Comparison", |
| "sec_num": "6.2" |
| }, |
| { |
| "text": "We also carry out some error analysis to provide some insights about how non-monotonicity is improving accuracy with respect to the original Covington parser. In particular, we notice that nonmonotonicity tends to be more beneficial on projective than on non-projective arcs. In addition, the non-monotonic algorithm presents a notable performance on long arcs (which are more prone to error propagation): average precision on arcs with length greater than 7 goes from 58.41% in the monotonic version to 63.19% in the non-monotonic parser, which may mean that non-monotonicity is alleviating the effect of error propagation. Finally, we study the effectiveness of non-monotonic arcs (i.e., those that break a previously-created arc), obtaining that, on average across all datasets tested, 36.86% of the arc transitions taken were non-monotonic, replacing an existing arc with a new one. Out of these transitions, 60.31% created a gold arc, and only 5.99% were harmful (i.e., they replaced a previously-built gold arc with an incorrect arc), with the remaining cases creating non-gold arcs without introducing extra errors (replacing a non-gold arc with another). These results back up the usefulness of non-monotonicity in transition-based parsing.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Error Analysis", |
| "sec_num": "6.3" |
| }, |
| { |
| "text": "We presented a novel, fully non-monotonic variant of the well-known non-projective Covington parser, trained with a dynamic oracle. Due to the unpredictability of a non-monotonic scenario, the real loss of each configuration cannot be computed. To overcome this, we proposed three different loss expressions that closely bound the loss and enable us to implement a practical non-monotonic dynamic oracle.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "7" |
| }, |
| { |
| "text": "On average, our non-monotonic algorithm obtains better performance than the monotonic version, regardless of which of the variants of the loss calculation is used. In particular, one of the loss expressions developed proved very promising by providing the best average accuracy, in spite of being the farthest approximation from the actual loss. On the other hand, the proposed lower bound makes the non-monotonic oracle the fastest one among all dynamic oracles developed for the non-projective Covington algorithm.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "7" |
| }, |
| { |
| "text": "To our knowledge, this is the first implementation of non-monotonicity for a nonprojective parsing algorithm, and the first approximate dynamic oracle that uses close, efficientlycomputable approximations of the loss, showing this to be a feasible alternative when it is not practical to compute the actual loss.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "7" |
| }, |
| { |
| "text": "While we used a perceptron classifier for our experiments, our oracle could also be used in neuralnetwork implementations of greedy transitionbased parsing (Chen and Manning, 2014; Dyer et al., 2015) , providing an interesting avenue for future work. We believe that gains from both techniques should be complementary, as they apply to orthogonal components of the parsing system (the scoring model vs. the transition system), although we might see a \"diminishing returns\"effect.", |
| "cite_spans": [ |
| { |
| "start": 156, |
| "end": 180, |
| "text": "(Chen and Manning, 2014;", |
| "ref_id": "BIBREF1" |
| }, |
| { |
| "start": 181, |
| "end": 199, |
| "text": "Dyer et al., 2015)", |
| "ref_id": "BIBREF3" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "7" |
| }, |
| { |
| "text": "In general A is a forest, but it can be converted to a tree by linking headless nodes as dependents of an artificial root node at position 0. When we refer to parser outputs as trees, we assume that this transformation is being implicitly made.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "Note that, in this scenario, the new head must also be wrong because otherwise the newly created arc would be an arc of I(c, tG) (and therefore, would not be breaking a cycle in A \u222a I(c, tG)). However, replacing a wrong attachment with another wrong attachment need not increase loss.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "We excluded the languages from CoNLL-X that also appeared in CoNLL-XI, i.e., if a language was present in both shared tasks, we used the latest version.5 No feature optimization is performed since our priority in this paper is not to compete with state-of-the-art systems, but to prove, under uniform experimental settings, that our approach outperforms the baseline system.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| } |
| ], |
| "back_matter": [ |
| { |
| "text": "This research has received funding from the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation programme (grant agreement No 714150 -FASTPARSE). The second author has received funding from the TELEPARES-UDC project (FFI2014-51978-C2-2-R) from MINECO.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Acknowledgments", |
| "sec_num": null |
| } |
| ], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "CoNLL-X shared task on multilingual dependency parsing", |
| "authors": [ |
| { |
| "first": "Sabine", |
| "middle": [], |
| "last": "Buchholz", |
| "suffix": "" |
| }, |
| { |
| "first": "Erwin", |
| "middle": [], |
| "last": "Marsi", |
| "suffix": "" |
| } |
| ], |
| "year": 2006, |
| "venue": "Proceedings of the 10th Conference on Computational Natural Language Learning (CoNLL)", |
| "volume": "", |
| "issue": "", |
| "pages": "149--164", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Sabine Buchholz and Erwin Marsi. 2006. CoNLL-X shared task on multilingual dependency parsing. In Proceedings of the 10th Conference on Computa- tional Natural Language Learning (CoNLL). pages 149-164. http://www.aclweb.org/anthology/W06- 2920.", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "A fast and accurate dependency parser using neural networks", |
| "authors": [ |
| { |
| "first": "Danqi", |
| "middle": [], |
| "last": "Chen", |
| "suffix": "" |
| }, |
| { |
| "first": "Christopher", |
| "middle": [], |
| "last": "Manning", |
| "suffix": "" |
| } |
| ], |
| "year": 2014, |
| "venue": "Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics", |
| "volume": "", |
| "issue": "", |
| "pages": "740--750", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Danqi Chen and Christopher Manning. 2014. A fast and accurate dependency parser using neural networks. In Proceedings of the 2014 Confer- ence on Empirical Methods in Natural Language Processing (EMNLP). Association for Computa- tional Linguistics, Doha, Qatar, pages 740-750. http://www.aclweb.org/anthology/D14-1082.", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "A fundamental algorithm for dependency parsing", |
| "authors": [ |
| { |
| "first": "A", |
| "middle": [], |
| "last": "Michael", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Covington", |
| "suffix": "" |
| } |
| ], |
| "year": 2001, |
| "venue": "Proceedings of the 39th Annual ACM Southeast Conference", |
| "volume": "", |
| "issue": "", |
| "pages": "95--102", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Michael A. Covington. 2001. A fundamental algorithm for dependency parsing. In Proceedings of the 39th Annual ACM Southeast Conference. ACM, New York, NY, USA, pages 95-102.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "Transitionbased dependency parsing with stack long shortterm memory", |
| "authors": [ |
| { |
| "first": "Chris", |
| "middle": [], |
| "last": "Dyer", |
| "suffix": "" |
| }, |
| { |
| "first": "Miguel", |
| "middle": [], |
| "last": "Ballesteros", |
| "suffix": "" |
| }, |
| { |
| "first": "Wang", |
| "middle": [], |
| "last": "Ling", |
| "suffix": "" |
| }, |
| { |
| "first": "Austin", |
| "middle": [], |
| "last": "Matthews", |
| "suffix": "" |
| }, |
| { |
| "first": "Noah", |
| "middle": [ |
| "A" |
| ], |
| "last": "Smith", |
| "suffix": "" |
| } |
| ], |
| "year": 2015, |
| "venue": "Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing", |
| "volume": "1", |
| "issue": "", |
| "pages": "334--343", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Chris Dyer, Miguel Ballesteros, Wang Ling, Austin Matthews, and Noah A. Smith. 2015. Transition- based dependency parsing with stack long short- term memory. In Proceedings of the 53rd An- nual Meeting of the Association for Computational Linguistics and the 7th International Joint Con- ference on Natural Language Processing (Volume 1: Long Papers). Association for Computa- tional Linguistics, Beijing, China, pages 334-343. http://www.aclweb.org/anthology/P15-1033.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "A dynamic oracle for arc-eager dependency parsing", |
| "authors": [ |
| { |
| "first": "Yoav", |
| "middle": [], |
| "last": "Goldberg", |
| "suffix": "" |
| }, |
| { |
| "first": "Joakim", |
| "middle": [], |
| "last": "Nivre", |
| "suffix": "" |
| } |
| ], |
| "year": 2012, |
| "venue": "Proceedings of COLING 2012. Association for Computational Linguistics", |
| "volume": "", |
| "issue": "", |
| "pages": "959--976", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Yoav Goldberg and Joakim Nivre. 2012. A dynamic oracle for arc-eager dependency parsing. In Pro- ceedings of COLING 2012. Association for Compu- tational Linguistics, Mumbai, India, pages 959-976. http://www.aclweb.org/anthology/C12-1059.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "Training deterministic parsers with non-deterministic oracles", |
| "authors": [ |
| { |
| "first": "Yoav", |
| "middle": [], |
| "last": "Goldberg", |
| "suffix": "" |
| }, |
| { |
| "first": "Joakim", |
| "middle": [], |
| "last": "Nivre", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "Transactions of the Association for Computational Linguistics", |
| "volume": "1", |
| "issue": "", |
| "pages": "403--414", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Yoav Goldberg and Joakim Nivre. 2013. Training deterministic parsers with non-deterministic oracles. Transactions of the Association for Computational Linguistics 1:403-414.", |
| "links": null |
| }, |
| "BIBREF6": { |
| "ref_id": "b6", |
| "title": "An efficient dynamic oracle for unrestricted non-projective parsing", |
| "authors": [ |
| { |
| "first": "Carlos", |
| "middle": [], |
| "last": "G\u00f3mez", |
| "suffix": "" |
| }, |
| { |
| "first": "-Rodr\u00edguez", |
| "middle": [], |
| "last": "", |
| "suffix": "" |
| }, |
| { |
| "first": "Daniel", |
| "middle": [], |
| "last": "Fern\u00e1ndez-Gonz\u00e1lez", |
| "suffix": "" |
| } |
| ], |
| "year": 2015, |
| "venue": "Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing of the Asian Federation of Natural Language Processing", |
| "volume": "2", |
| "issue": "", |
| "pages": "256--261", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Carlos G\u00f3mez-Rodr\u00edguez and Daniel Fern\u00e1ndez- Gonz\u00e1lez. 2015. An efficient dynamic oracle for unrestricted non-projective parsing. In Proceed- ings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th Interna- tional Joint Conference on Natural Language Pro- cessing of the Asian Federation of Natural Language Processing, ACL 2015, July 26-31, 2015, Beijing, China, Volume 2: Short Papers. pages 256-261. http://aclweb.org/anthology/P/P15/P15-2042.pdf.", |
| "links": null |
| }, |
| "BIBREF7": { |
| "ref_id": "b7", |
| "title": "Divisible transition systems and multiplanar dependency parsing", |
| "authors": [ |
| { |
| "first": "Carlos", |
| "middle": [], |
| "last": "G\u00f3mez", |
| "suffix": "" |
| }, |
| { |
| "first": "-Rodr\u00edguez", |
| "middle": [], |
| "last": "", |
| "suffix": "" |
| }, |
| { |
| "first": "Joakim", |
| "middle": [], |
| "last": "Nivre", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "Computational Linguistics", |
| "volume": "39", |
| "issue": "4", |
| "pages": "799--845", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Carlos G\u00f3mez-Rodr\u00edguez and Joakim Nivre. 2013. Divisible transition systems and multiplanar dependency parsing. Com- putational Linguistics 39(4):799-845.", |
| "links": null |
| }, |
| "BIBREF8": { |
| "ref_id": "b8", |
| "title": "A polynomial-time dynamic oracle for non-projective dependency parsing", |
| "authors": [ |
| { |
| "first": "Carlos", |
| "middle": [], |
| "last": "G\u00f3mez-Rodr\u00edguez", |
| "suffix": "" |
| }, |
| { |
| "first": "Francesco", |
| "middle": [], |
| "last": "Sartorio", |
| "suffix": "" |
| }, |
| { |
| "first": "Giorgio", |
| "middle": [], |
| "last": "Satta", |
| "suffix": "" |
| } |
| ], |
| "year": 2014, |
| "venue": "Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP)", |
| "volume": "", |
| "issue": "", |
| "pages": "917--927", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Carlos G\u00f3mez-Rodr\u00edguez, Francesco Sartorio, and Giorgio Satta. 2014. A polynomial-time dy- namic oracle for non-projective dependency parsing. In Proceedings of the 2014 Confer- ence on Empirical Methods in Natural Lan- guage Processing (EMNLP). Association for Computational Linguistics, pages 917-927.", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "A non-monotonic arc-eager transition system for dependency parsing", |
| "authors": [ |
| { |
| "first": "Matthew", |
| "middle": [], |
| "last": "Honnibal", |
| "suffix": "" |
| }, |
| { |
| "first": "Yoav", |
| "middle": [], |
| "last": "Goldberg", |
| "suffix": "" |
| }, |
| { |
| "first": "Mark", |
| "middle": [], |
| "last": "Johnson", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "Proceedings of the Seventeenth Conference on Computational Natural Language Learning", |
| "volume": "", |
| "issue": "", |
| "pages": "163--172", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Matthew Honnibal, Yoav Goldberg, and Mark John- son. 2013. A non-monotonic arc-eager trans- ition system for dependency parsing. In Proceed- ings of the Seventeenth Conference on Computa- tional Natural Language Learning, CoNLL 2013, Sofia, Bulgaria, August 8-9, 2013. pages 163- 172. http://aclweb.org/anthology/W/W13/W13- 3518.pdf.", |
| "links": null |
| }, |
| "BIBREF10": { |
| "ref_id": "b10", |
| "title": "An improved non-monotonic transition system for dependency parsing", |
| "authors": [ |
| { |
| "first": "Matthew", |
| "middle": [], |
| "last": "Honnibal", |
| "suffix": "" |
| }, |
| { |
| "first": "Mark", |
| "middle": [], |
| "last": "Johnson", |
| "suffix": "" |
| } |
| ], |
| "year": 2015, |
| "venue": "Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing", |
| "volume": "", |
| "issue": "", |
| "pages": "1373--1378", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Matthew Honnibal and Mark Johnson. 2015. An improved non-monotonic transition system for de- pendency parsing. In Proceedings of the 2015 Conference on Empirical Methods in Natural Lan- guage Processing. Association for Computational Linguistics, Lisbon, Portugal, pages 1373-1378. http://aclweb.org/anthology/D15-1162.", |
| "links": null |
| }, |
| "BIBREF11": { |
| "ref_id": "b11", |
| "title": "Finding all the elementary circuits of a directed graph", |
| "authors": [ |
| { |
| "first": "B", |
| "middle": [], |
| "last": "Donald", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Johnson", |
| "suffix": "" |
| } |
| ], |
| "year": 1975, |
| "venue": "SIAM Journal on Computing", |
| "volume": "4", |
| "issue": "1", |
| "pages": "77--84", |
| "other_ids": { |
| "DOI": [ |
| "10.1137/0204007" |
| ] |
| }, |
| "num": null, |
| "urls": [], |
| "raw_text": "Donald B. Johnson. 1975. Finding all the ele- mentary circuits of a directed graph. SIAM Journal on Computing 4(1):77-84. ht- tps://doi.org/10.1137/0204007.", |
| "links": null |
| }, |
| "BIBREF12": { |
| "ref_id": "b12", |
| "title": "Characterizing the errors of data-driven dependency parsing models", |
| "authors": [ |
| { |
| "first": "Ryan", |
| "middle": [], |
| "last": "Mcdonald", |
| "suffix": "" |
| }, |
| { |
| "first": "Joakim", |
| "middle": [], |
| "last": "Nivre", |
| "suffix": "" |
| } |
| ], |
| "year": 2007, |
| "venue": "Proceedings of the", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Ryan McDonald and Joakim Nivre. 2007. Char- acterizing the errors of data-driven dependency parsing models. In Proceedings of the 2007", |
| "links": null |
| }, |
| "BIBREF13": { |
| "ref_id": "b13", |
| "title": "Natural Language Processing and Computational Natural Language Learning (EMNLP-CoNLL)", |
| "authors": [], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Joint Conference on Empirical Methods in Natural Language Processing and Computational Natural Language Learning (EMNLP-CoNLL). pages 122-", |
| "links": null |
| }, |
| "BIBREF14": { |
| "ref_id": "b14", |
| "title": "An efficient algorithm for projective dependency parsing", |
| "authors": [ |
| { |
| "first": "Joakim", |
| "middle": [], |
| "last": "Nivre", |
| "suffix": "" |
| } |
| ], |
| "year": 2003, |
| "venue": "Proceedings of the 8th International Workshop on Parsing Technologies (IWPT 03). ACL/SIGPARSE", |
| "volume": "", |
| "issue": "", |
| "pages": "149--160", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Joakim Nivre. 2003. An efficient algorithm for pro- jective dependency parsing. In Proceedings of the 8th International Workshop on Parsing Technologies (IWPT 03). ACL/SIGPARSE, pages 149-160.", |
| "links": null |
| }, |
| "BIBREF15": { |
| "ref_id": "b15", |
| "title": "Algorithms for Deterministic Incremental Dependency Parsing", |
| "authors": [ |
| { |
| "first": "Joakim", |
| "middle": [], |
| "last": "Nivre", |
| "suffix": "" |
| } |
| ], |
| "year": 2008, |
| "venue": "Computational Linguistics", |
| "volume": "34", |
| "issue": "4", |
| "pages": "513--553", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Joakim Nivre. 2008. Algorithms for Determ- inistic Incremental Dependency Parsing. Computational Linguistics 34(4):513-553.", |
| "links": null |
| }, |
| "BIBREF17": { |
| "ref_id": "b17", |
| "title": "The CoNLL 2007 shared task on dependency parsing", |
| "authors": [ |
| { |
| "first": "Joakim", |
| "middle": [], |
| "last": "Nivre", |
| "suffix": "" |
| }, |
| { |
| "first": "Johan", |
| "middle": [], |
| "last": "Hall", |
| "suffix": "" |
| }, |
| { |
| "first": "Sandra", |
| "middle": [], |
| "last": "K\u00fcbler", |
| "suffix": "" |
| }, |
| { |
| "first": "Ryan", |
| "middle": [], |
| "last": "Mcdonald", |
| "suffix": "" |
| }, |
| { |
| "first": "Jens", |
| "middle": [], |
| "last": "Nilsson", |
| "suffix": "" |
| }, |
| { |
| "first": "Sebastian", |
| "middle": [], |
| "last": "Riedel", |
| "suffix": "" |
| }, |
| { |
| "first": "Deniz", |
| "middle": [], |
| "last": "Yuret", |
| "suffix": "" |
| } |
| ], |
| "year": 2007, |
| "venue": "Proceedings of the CoNLL Shared Task Session of EMNLP-CoNLL", |
| "volume": "", |
| "issue": "", |
| "pages": "915--932", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Joakim Nivre, Johan Hall, Sandra K\u00fcbler, Ryan McDonald, Jens Nilsson, Sebastian Riedel, and Deniz Yuret. 2007. The CoNLL 2007 shared task on dependency parsing. In Pro- ceedings of the CoNLL Shared Task Session of EMNLP-CoNLL 2007. pages 915-932. http://www.aclweb.org/anthology/D/D07/D07- 1096.pdf.", |
| "links": null |
| }, |
| "BIBREF18": { |
| "ref_id": "b18", |
| "title": "Depth-first search and linear graph algorithms", |
| "authors": [ |
| { |
| "first": "", |
| "middle": [], |
| "last": "Robert Endre Tarjan", |
| "suffix": "" |
| } |
| ], |
| "year": 1972, |
| "venue": "SIAM J. Comput", |
| "volume": "1", |
| "issue": "2", |
| "pages": "146--160", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Robert Endre Tarjan. 1972. Depth-first search and linear graph algorithms. SIAM J. Comput. 1(2):146-160. http://dblp.uni- trier.de/db/journals/siamcomp/siamcomp1.html.", |
| "links": null |
| }, |
| "BIBREF19": { |
| "ref_id": "b19", |
| "title": "Performance-Oriented Dependency Parsing. Doctoral dissertation", |
| "authors": [ |
| { |
| "first": "Alexander", |
| "middle": [], |
| "last": "Volokh", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Alexander Volokh. 2013. Performance-Oriented De- pendency Parsing. Doctoral dissertation, Saarland University, Saarbr\u00fccken, Germany.", |
| "links": null |
| }, |
| "BIBREF20": { |
| "ref_id": "b20", |
| "title": "Dependency parsing with efficient feature extraction", |
| "authors": [ |
| { |
| "first": "Alexander", |
| "middle": [], |
| "last": "Volokh", |
| "suffix": "" |
| }, |
| { |
| "first": "G\u00fcnter", |
| "middle": [], |
| "last": "Neumann", |
| "suffix": "" |
| } |
| ], |
| "year": 2012, |
| "venue": "Lecture Notes in Computer Science", |
| "volume": "7526", |
| "issue": "", |
| "pages": "253--256", |
| "other_ids": { |
| "DOI": [ |
| "10.1007/978-3-642-33347-7" |
| ] |
| }, |
| "num": null, |
| "urls": [], |
| "raw_text": "Alexander Volokh and G\u00fcnter Neumann. 2012. De- pendency parsing with efficient feature extrac- tion. In Birte Glimm and Antonio Kr\u00fcger, editors, KI. Springer, volume 7526 of Lec- ture Notes in Computer Science, pages 253-256. https://doi.org/10.1007/978-3-642-33347-7.", |
| "links": null |
| }, |
| "BIBREF21": { |
| "ref_id": "b21", |
| "title": "More accurate tests for the statistical significance of result differences", |
| "authors": [ |
| { |
| "first": "Alexander", |
| "middle": [], |
| "last": "Yeh", |
| "suffix": "" |
| } |
| ], |
| "year": 2000, |
| "venue": "Proceedings of the 18th International Conference on Computational Linguistics (COLING)", |
| "volume": "", |
| "issue": "", |
| "pages": "947--953", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Alexander Yeh. 2000. More accurate tests for the stat- istical significance of result differences. In Proceed- ings of the 18th International Conference on Com- putational Linguistics (COLING). pages 947-953. http://aclweb.org/anthology/C/C00/C00-2137.pdf.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "text": "w n ) = [], [], [1 . . . n], \u2205 , and execute transitions chosen from those in Figure 1 until a terminal configuration of the form { \u03bb 1 , \u03bb 2 , [], A \u2208 C} is reached. At that point, the sentence's parse tree is obtained from A. 2", |
| "num": null, |
| "uris": null, |
| "type_str": "figure" |
| }, |
| "FIGREF1": { |
| "text": "r are the left/right valencies (number of left/right dependents); and s l , s r the left/right label sets (dependency labels of left/right dependents).", |
| "num": null, |
| "uris": null, |
| "type_str": "figure" |
| }, |
| "TABREF1": { |
| "type_str": "table", |
| "text": "L0pv l ; L0ws l ; L0ps l ; L0wsr; L0psr; L1w; L1p; L1wp; R0w; R0p; R0wp; R 0h w; R 0h p;R 0h l; R 0h2 w; R 0h2 p; R 0l w; R 0l p; R 0l l; R 0l w; R 0l p; R 0l l; R0wd; R0pd; R0wv l ; R0pv l ; R0ws l ; R0ps l ;", |
| "num": null, |
| "html": null, |
| "content": "<table><tr><td>0l l; L0rw; L0rp; L0rl; L0wd; L0pd; L0wvr; L0pvr; L0wv l ; R1w; R1p; R1wp;</td></tr><tr><td>R2w; R2p; R2wp; CLw; CLp; CLwp; CRw; CRp; CRwp;</td></tr><tr><td>Pairs</td></tr><tr><td>L0wp+R0wp; L0wp+R0w; L0w+R0wp; L0wp+R0p;</td></tr><tr><td>L0p+R0wp; L0w+R0w; L0p+R0p; R0p+R1p; L0w+R0wd;</td></tr><tr><td>L0p+R0pd;</td></tr><tr><td>Triples</td></tr><tr><td>R0p+R1p+R2p; L0p+R0p+R1p; L 0h p+L0p+R0p;</td></tr><tr><td>L0p+L 0l p+R0p; L0p+L 0r p+R0p; L0p+R0p+R 0l p; L0p+L 0l p+L 0l p; L0p+L 0r p+L0rp; L0p+L 0h p+L 0h2 p; R0p+R 0l p+R 0l p;</td></tr></table>" |
| }, |
| "TABREF2": { |
| "type_str": "table", |
| "text": "Feature templates. L 0 and R 0 denote the left and right focus words; L 1 , L 2 , . . . are the words to the left of L 0 and R 1 , R 2 , .", |
| "num": null, |
| "html": null, |
| "content": "<table/>" |
| }, |
| "TABREF4": { |
| "type_str": "table", |
| "text": "Parsing accuracy (UAS and LAS, including punctuation) of the Covington non-projective parser with static, and dynamic monotonic and non-monotonic oracles on CoNLL-XI (first block) and CoNLL-X (second block) datasets. For the dynamic non-monotonic oracle, we show the performance with the three loss expressions, where lower stands for the lower bound |U(c, t G )|, pc upper for the upper bound |U(c, t G )| + n pc (A \u222a I(c, t G )), and upper for the upper bound |U(c, t G )| + n c (A \u222a I(c, t G )). For each language, we run five experiments with the same setup but different seeds and report the averaged accuracy. Best results for each language are shown in boldface. Statistically significant improvements (\u03b1 = .05) of both dynamic oracles are marked with * if they are only over the static oracle, and with \u2020 if they are over the opposite dynamic oracle too.", |
| "num": null, |
| "html": null, |
| "content": "<table/>" |
| }, |
| "TABREF6": { |
| "type_str": "table", |
| "text": "", |
| "num": null, |
| "html": null, |
| "content": "<table><tr><td>: Comparison of the average Unlabeled</td></tr><tr><td>and Labeled Attachment Scores (including punc-</td></tr><tr><td>tuation) achieved by some widely-used transition-</td></tr><tr><td>based algorithms with dynamic oracles on nine</td></tr><tr><td>CoNLL-X datasets and all CoNLL-XI datatsets,</td></tr><tr><td>as well as their average parsing speed (sen-</td></tr><tr><td>tences per second across all datasets) measured</td></tr><tr><td>on a 2.30GHz Intel Xeon processor. The first</td></tr><tr><td>block corresponds to monotonic parsers, while the</td></tr><tr><td>second gathers non-monotonic parsers. All al-</td></tr><tr><td>gorithms are tested under our own implementa-</td></tr><tr><td>tion, except for the system developed by G\u00f3mez-</td></tr><tr><td>Rodr\u00edguez et al. (2014) (marked with *) where we</td></tr><tr><td>report the published results.</td></tr></table>" |
| } |
| } |
| } |
| } |
