Hexatagging: Projective Dependency Parsing as Tagging
Year: 2023

Abstract:
We introduce a novel dependency parser, the hexatagger, that constructs dependency trees by tagging the words in a sentence with elements from a finite set of possible tags. In contrast to many approaches to dependency parsing, our approach is fully parallelizable at training time, i.e., the structure-building actions needed to build a dependency parse can be predicted in parallel to each other. Additionally, exact decoding is linear in time and space complexity. Furthermore, we derive a probabilistic dependency parser that predicts hexatags using no more than a linear model with features from a pretrained language model, i.e., we forsake a bespoke architecture explicitly designed for the task. Despite the generality and simplicity of our approach, we achieve state-of-the-art performance of 96.4 LAS and 97.4 UAS on the Penn Treebank test set. Additionally, our parser’s linear time complexity and parallelism significantly improve computational efficiency, with a roughly 10-times speed-up over previous state-of-the-art models during decoding. https://github.com/rycolab/ parsing-as-tagging

heading: 1 Introduction
text: The combination of parallel computing hardware and highly parallelizable neural network architectures (Vaswani et al., 2017) has enabled the pretraining of language models on increasingly large amounts of data. In order to apply pretrained language models to downstream NLP tasks, many practitioners fine-tune the pretrained model while the task-specific architecture is jointly trained from scratch. Typically, the task-specific architecture is built upon the hidden representations generated by the final layer of a pretrained model. Exploiting pretrained language models in this manner has boosted the performance considerably on many NLP tasks (Devlin et al., 2019; Clark et al., 2020;
∗Equal contribution.
Aghajanyan et al., 2021). However, for the end-toend fine-tuning process to be fully parallelizable, it is also necessary to parallelize the training of the task-specific architecture. Unfortunately, due to the complexity of the output in many structured prediction tasks in natural language, e.g., in dependency parsing, state-of-the-art models still use architectures with limited parallelization during training (Mrini et al., 2020; Yang and Tu, 2022).
In an attempt to develop parsers parallelizable during training, a recent line of work recasts parsing as tagging (Li et al., 2018; Strzyz et al., 2019; Kitaev and Klein, 2020; Amini and Cotterell, 2022). Under this approach, a parse tree is linearized into a sequence of tags.1 The benefit of such a paradigm is that tagging can be done by only adding a linear classifier on top of a pretrained language model and the tags can, thus, be predicted independently. This leads to a parser that is highly parallelizable and whose training can be easily harmonized with the (parallelizable) fine-tuning of pretrained language models. During decoding, an exact algorithm is used to recover a valid sequence
1In some tagging-based dependency parsers, the cardinality of the set of tags even grows as a function of the length of the input sequence and, thus, is unbounded.
1453
of tags which is then converted back to a parse tree. Kitaev and Klein (2020) were the first to propose a parsing-as-tagging scheme with a constant tag space for constituency parsing and, additionally, the first to achieve results competitive with the stateof-the-art non-parallelizable constituency parsers using such a tagger. However, for dependency parsing, all dependency parsing-as-tagging schemes in the literature (Li et al., 2018; Strzyz et al., 2019; Vacareanu et al., 2020) have infinite tag sets whose cardinality grows with the length of the input sequence, which limits such parsers’ efficiency and generality (Strzyz et al., 2019). Moreover, in some cases, this growth hinders generalization to sentences longer than the longest training sentence. Furthermore, tagging-based dependency parsers still do not perform competitively with the bestperforming parsers in the literature (Li et al., 2018).
In this paper, we propose a novel way of framing projective dependency parsing as a tagging task. Our approach makes use of 6 distinct tags, motivating us to naming the scheme hexatagger. In our experiments, hexatagger achieves state-of-the-art performance on the English Penn Treebank (PTB; Marcus et al., 1993) test set. Notably, it outperforms parsers with more computationally expensive training procedures and extra constituency annotations, e.g., the parser developed by Mrini et al. (2020). Furthermore, hexatagger achieves results competitive to Yang and Tu’s (2022) parser on the Chinese Penn Treebank (CTB; Xue et al., 2005) test set and 12 languages on the pseudo-projectivized data from the Universal Dependencies (UD2.2; Nivre et al., 2018) benchmark. In terms of efficiency, our experiments suggest that hexatagger is 10 times faster than previous top-performing parsers, and consumes significantly less memory, despite using an exact dynamic program for decoding.

heading: 2 Hexatagging
text: In this section, we introduce hexatagging, a tagging scheme that consists of 6 unique tag types. We further prove by construction that there exists an injective mapping between valid sequences of hexatags and dependency trees.

heading: 2.1 Binary Head Trees
text: Before going into the details on how to represent dependency trees with a sequence of tags, we introduce binary head trees (BHTs), a simple formalism that serves as a useful intermediary between
dependency trees and sequence of hexatags. Intuitively, a BHT is a special form of a constituency tree where each internal node is either labeled L when the head of the derived constituent is in the left subtree or R when the head is in the right subtree. See Fig. 1 for a visual depiction of a BHT. In the next theorem, we formally state the relationship between the set of dependency trees and BHTs.
Theorem 1. There exists a bijective2 function that maps every projective dependency tree to a BHT.
In the following two paragraphs, we sketch a construction that such a function exists, i.e., we describe how to map any dependency tree to a BHT and then how to map back any BHT to a dependency tree and back again.
Projective Dependency Trees to BHTs. To convert a dependency tree to a BHT, we start from the root and do a depth-first traversal of the dependency tree. To avoid spurious ambiguity (Eisner and Satta, 1999), we canonically order arcs of the tree by processing the arcs left to right and inside out.3 Algorithmically, converting a dependency tree to a BHT proceeds as follows. When we first visit a word, we push it onto a stack and proceed with visiting its dependents. When there is no dependent word left to visit, we create a new node ( L or R ) and attach the top two elements in the stack as the left and right child of this node. A stepby-step demonstration of this algorithm is shown in Fig. 2 and pseudocode is provided in Alg. 1.
BHTs to Projective Dependency Trees. To convert a BHT back to the dependency tree we follow Alg. 2. Algorithmically, we process BHT in a depth-first fashion. Upon visiting R or L nodes, we combine the top two elements in the stack by creating a dependency arc between them. The direction of the arc is determined by the label of the node ( R or L ). See Fig. 3 for an example. Once the dependency tree is converted to a BHT, we can linearize it to a sequence of hexatags in a straightforward manner. Theorem 2 states the relationship between BHTs and hexatags formally.
Theorem 2. There exists a total and injective function that maps every BHT to a valid hexatag sequence, i.e., in other words, every BHT can be
2We remark that the bijectivitiy follows from a canonical ordering (left-to-right and inside-out) of a node’s dependents.
3One can also process the right arcs first. In our experiments, however, we observed no significant difference in the performance of the parser, see App. C for more analysis.
for a dependency tree A B C D . The top of the stack is on the right.
mapped to a unique hexatag sequence. However, some hexatag sequences do not correspond to BHTs, i.e., the function is not surjective.
In the following subsections, we prove by construction that such a function exists. Throughout the rest of the paper, we refer to those haxatagging sequences that do correspond to BHTs as valid.

heading: 2.2 From BHT to Hexatags
text: To transform a given BHT to a sequence of hexatags, we enumerate the action sequence that a left-corner shift–reduce parser would take when parsing this BHT (Johnson, 1998). Left-corner parsers have actions that align more closely with the input sequence than top-down or bottom-up shift–reduce actions and, thus, offer a better linearization for tagging tasks (Amini and Cotterell, 2022). A simple explanation of this linearization process is given by Kitaev and Klein (2020, §3.1). Their algorithm involves an in-order traversal of the tree. Upon visiting each node, we generate a tag that includes the direction of the arc that attaches
the node to its parent, i.e., whether that node is a left or a right child of its parent, and the label of the node. When traversing a BHT, this paradigm results in 6 distinct tag types: • →: this terminal node is the right child of its
parent; • →: this terminal node is the left child of its par-
ent; • ⇒R ( ⇒L): this non-terminal node is the right child
of its parent and the head of the corresponding constituent is on the right (respectively, left) subtree; • ⇒R ( ⇒L): this non-terminal node is the left child of its parent and the head of the corresponding constituent is on the right (respectively, left) subtree. For an input sequence w = w1 · · ·wN , this process gives us a hexatag sequence of length 2N − 1. Fig. 1 depicts tree-to-tags transformation through an example.
Labeled Dependency Trees. When converting a labeled dependency tree to a sequence of hexatags, the arc labels must be encoded in the tags. Therefore, while reading a terminal node, we concatenate the label of the arc that connects the node to its parent with the hexatag. In this case, the number of distinct tags would be O(|A|), where |A| is the number of unique arc labels. For example, in Fig. 1 the hexatag generated while processing she is: ⟨ →, nsubj⟩.

heading: 2.3 From Hexatags to Dependency Trees
text: To transform a sequence of hexatags back to a dependency tree, we again go through a two-step process. First, we again interpret hexatags as actions in a left-corner shift–reduce transition system to construct a BHT. The actions in such a transition system are as follows: • →: shift the leaf node into the stack; • ⇒R ( ⇒L): create a new node labeled R (respec-
tively, L ), attach the top element in the stack as its left child, and attach a dummy node as its right child (∅ in step 2 in Fig. 3); • →: pop the subtree on the top of the stack. Replace the dummy node in the subtree with the terminal node. Push the subtree back to the stack; • ⇒R ( ⇒L): create a new node labeled R (respectively, L ). Pop the top element of the stack, attach it as the new node’s left child, and set a dummy node as the node’s right child. Pop another subtree of the stack, identify the dummy

heading: 3 Probability Model
text: In this section, we explain how to predict hexatags in parallel. Our tagging model predicts two hexatags for each word in the input sequence with the exception of that last word, for which we only predict one tag. As discussed in §2.1, a hexatagger produces a sequence of 2N − 1 tags t = [t1, t2, . . . , t2N−1] for an input sequence of length N , w = w1w2 · · ·wN . Therefore, an intuitive way to match the tag sequence with the input sequence is to assign two tags to each word. We denote a training corpus S of M tuples of input sequences and tag sequences {(wm, tm)}Mm=1.
To learn the scoring function over tags, we follow the same independence assumption as in (Kitaev and Klein, 2020), i.e., the probability of predicting each tag is independent of other tags given the input sequence. This assumption barely harms model performance (see Amini and
Cotterell, 2022, Table 3), but significantly speeds up the training process by enabling each tag to be predicted in parallel, and complexity reduces by a factor of O(N). The training objective is to minimize the negative log-likelihood of the gold-standard tag sequences, i.e.
L(θ) = − ∑
(w,t)∈S log pθ(t | w) (1a)
= − ∑
(w,t)∈S log
2N−1∏
n=1
pθ(tn | w) (1b)
= − ∑
(w,t)∈S
( N∑
n=1
log pθ(t2n−1 | w) (1c)
+
N−1∑
n=1
log pθ(t2n | w) )
where θ refers collectively to the parameters of the two linear projections and the parameters of the pretrained model. To obtain pθ(t2n | w) and pθ(t2n+1 | w), we apply two independent linear projections on the contextualized representation of wn4 given by a pretrained model and convert that to a probability distribution using softmax.

heading: 4 Decoding
text: Our goal in this section is to develop an efficient algorithm to find the highest-scoring hexatag sequence under the model developed in §3. As stated in Theorem 2, the transformation function between BHTs and hexatag sequences is not surjective, i.e., not all the tag sequences can be transformed back into a BHT. Therefore, we need to find a valid hexatag sequence with the maximum probability under the model that can be transformed back to a BHT. Once such hexatag sequence is found, we can follow the two-step algorithm described in §2.3 to obtain the corresponding dependency tree.
To find the highest-scoring valid hexatag sequence, we follow the linear-time algorithm developed by Kitaev and Klein (2020). For a hexatag sequence to be valid, we should be able to interpret it as actions in a left-corner shift–reduce transitions system, described in §2.3. Concretely:
• The first action can only be → because other actions need at least one item in the stack; • The actions ⇒L, ⇒R can only be performed if there is at least two items in the stack;
4If a word consists of more than one subword, we apply the projection to the last subword.
PTB CTB
Model UAS LAS UAS LAS
Zhou and Zhao (2019)∗ 97.0 95.4 91.2 89.2 Mrini et al. (2020)∗ 97.4 96.3 94.6 89.3
Chen and Manning (2014) 91.8 89.6 83.9 82.4 Dozat and Manning (2017) 95.7 94.1 89.3 88.2
• After performing all the actions, the stack should contain a single element. The above shows that the validity of a hexatag sequence only depends on the number of elements in the stack at each point of the derivation.5

heading: 5 Experiments
text: We conduct experiments on the English Penn Treebank (PTB; Marcus et al., 1993), the Chinese Penn Treebank (CTB; Xue et al., 2005), and the Universal Dependencies 2.2 (UD2.2; Nivre et al., 2018). For UD2.2, we adopt the pseudo-projective transformation (Nivre and Nilsson, 2005) to convert non-projective trees into projective trees following previous work (Wang and Tu, 2020; Yang and Tu, 2022). We report dataset statistics in App. E and hyperparameter settings in App. F.
Accuracy. We train the hexatagger model based on XLNet (Yang et al., 2019) and report the results on PTB and CTB in Table 2. Furthermore, we eval-
5Specifically, The decoding algorithm can be thought of as constructing a lattice where each node corresponds to the number of elements in the stack for each transition step (N×d nodes for maximum stack size of d, d ≤ N ). Each transition corresponds to performing a valid action. The score of the tag at step n is set to the negative log probability − log pθ(tn | w) of the corresponding hexatag given by the model. Finally, we remark that our decoding algorithm is essentially a shortestpath dynamic program that finds the highest-scoring valid hexatag sequence. See Amini and Cotterell (2022, §5.1) for a deeper discussion of this point.
Speed (sent/s) ↑ Memory (GB) ↓ Sent length Hexatagger Biaffine Hexatagger Biaffine

heading: 32 2916 493 2.9 4.5
text: uate hexatagger in a set of 12 topologically diverse languages on UD corpus, where we use Multilingual BERT (Devlin et al., 2019) as the underlying model (see Table 1). In PTB, we observe that hexatagger achieves state-of-the-art results, compared to models with custom architectures and even in some cases with extra annotation. In CTB and UD, hexatagger follows the best performance closely.
Efficiency. We compare the efficiency of hexatagger with biaffine modules,6 which are the backbone of many neural graph-based parsers (Kiperwasser and Goldberg, 2016; Dozat and Manning, 2017; Mrini et al., 2020; Yang and Tu, 2022). As depicted in Table 3, we observe that our hexatagger is an order of magnitude faster and consumes less memory. Further analysis is included in App. C.

heading: 6 Conclusion
text: In summary, hexatagging, our novel scheme, offers a parallelizable and efficiently decodable backbone for dependency parsing. Without relying on custom architecture for dependency parsing, the hexatagger achieves state-of-the-art accuracy on several datasets using no more than a pretrained language model and linear classifiers.
6By biaffine model we refer to a slim parameterization of a dependency parser that scores the existence of a dependency between wi and wj using a biaffine attention layer over the words’ contextualized representations.
Limitations
Non-projectivity. The primary theoretical limitation of hexatagger is that it can only produce projective dependency trees. We would like to explore the possibility of extending hexatagger to non-projective parsing for future work.
Interpretibility. As a trade-off for efficiency, hexatagger does not model dependency arcs directly. Compared to graph-based models that explicitly score arc scores between pairs of words, it is more difficult to interpret the output of hexatagger.
Ethics Statement
We do not believe the work presented here further amplifies biases already present in the datasets. Therefore, we foresee no ethical concerns in this work.

heading: Acknowledgments
text: We would like to thank Tim Vieira for his invaluable feedback throughout the process of this paper. Afra Amini is supported by ETH AI Center doctoral fellowship.

heading: A Algorithms
text: Algorithm 1 Create a BHT from a dependency tree. 1: procedure DEP2TREE(head) 2: stack.push(head) 3: for dep in LEFTDEP(head) : 4: DEP2TREE(dep) 5: left← stack.pop() 6: right← stack.pop() 7: stack.push(MAKENODE( R , left, right)) 8: for dep in RIGHTDEP(head) : 9: DEP2TREE(dep) 10: left← stack.pop() 11: right← stack.pop() 12: stack.push(MAKENODE( L , left, right))
Algorithm 2 Create a dependency tree from a BHT. 1: procedure TREE2DEP(node) 2: if node is leaf : 3: return node 4: left← TREE2DEP(node.left) 5: right← TREE2DEP(node.right) 6: if node is L :
7: return MAKEARC(left right )
8: return MAKEARC(left right )

heading: B Related Work
text: Traditionally, approaches to dependency parsing have been taxonomized into graph-based and transition-based parsers. The authors of this paper take the stance that this distinction is misleading because the difference lies not in the models themselves, but rather in whether exact or approximate inference algorithms are employed. For instance, Kuhlmann et al. (2011) gives exact algorithms for transition-based dependency parsers, which exposes the inability to formally distinguish graph-based and transition-based parsers. Thus, we classify our related work into sections: exact and approximate decoding. Further, we review works on tagging-based parsing which is the most relevant line of work to this paper.
Exact Decoding. Most exact algorithms for projective dependency parsing models apply a modified form of the CKY algorithm on nested dependency trees. The best runtime among the commonly deployed algorithms O ( N3 ) (Eisner, 1996), but algorithms based on fast matrix multiplication exist and can achieve a lower runtime bound (Cohen and Gildea, 2016). However, exact decoding
of non-projective parsers is intractable unless under independence assumptions, e.g., edge factored assumption (McDonald and Satta, 2007). Edgefactored parsers (McDonald et al., 2005; Dozat et al., 2017) construct graphs by scoring all possible arcs between each pair of words. They then use the maximum spanning tree (MST) finding algorithms for decoding to build the valid dependency trees with maximum score in O ( N2 ) (Zmigrod et al., 2020). The discussed algorithms are exact in inferring the dependency structure, however, they are neither fast nor parallelizable.
Approximate Decoding. Despite not being exact, transition-based parsers offer faster and typically linear-time parsing algorithms (Kudo and Matsumoto, 2002; Yamada and Matsumoto, 2003; Nivre, 2003). The dependency tree is inferred with a greedy search through transition system actions. Following this approach, actions are not predicted in parallel and the configuration of the transition system (stack and buffer) needs to be modeled with a neural network (Chen and Manning, 2014), which prevents using pretrained models out of the box.
Tagging-based parsing. Inspired by Bangalore and Joshi’s (1999) seminal work supertagging, a recent line of work aims to utilize pretrained models and parse dependency trees by inferring tags for each word in the input sequence. Li et al. (2018); Kiperwasser and Ballesteros (2018) predict the relative position of the dependent with respect to its parent as the tag. They then use beam tree constraints (Lee et al., 2016) to infer valid dependency trees. Strzyz et al. (2019) provides a framework for analyzing similar tagging schemes. Although these works have demonstrated potential in this area, none achieved state-of-the-art results compared to custom architectures and algorithms developed for dependency parsing. Additionally, the output space, or size of the tag set, is unrestricted, which limits the efficiency of this approach.

heading: C Analysis
text: LEFT-FIRST vs. RIGHT-FIRST. We examine the effect of the two orders of binarization of Alg. 1 in Table 4. In our experiments, the choice of left-first or right-first order has little to no effect on parsing performance.

heading: D Efficiency Evaluation
text: For efficiency comparison, we use BERT-large as the base feature encoder for both Hexatagger and Biaffine. We use the English PTB test set and truncate or pad the input sentences to the control length. The results are averaged over 3 random runs on the same server with one Nvidia A100-80GB GPU. The other experimental settings are kept the same (i.e., the version of PyTorch and Transformer, FP32 precision, batching).

heading: E Datasets
text: Preprocessing. Following previous work (Kiperwasser and Goldberg, 2016; Dozat and Manning, 2017), the dependency annotations are derived by the Stanford Dependency converter v3.3.0 (de Marneffe and Manning, 2008) from the treebank annotations. Punctuation is omitted for evaluation. Gold part-of-speech tags are provided to the model both during training and evaluation following the code released by Mrini et al. (2020).
Some other authors use system-predicted partof-speech tags (Zhou and Zhao, 2019) or use mixed configurations. E.g., Yang and Tu (2022) uses gold part-of-speech tags on CTB and UD, while not using any on PTB, Dozat and Manning (2017) uses gold part-of-speech tags on CTB but systempredicted ones on PTB. Our preliminary experiments show that removing the usage of part-ofspeech information barely affects the UAS metric, and gives us a performance of 97.4 UAS and 95.8 LAS on PTB.
Splits. All the datasets splits are consistent with previous work. For PTB, we follow the standard split of Marcus et al. (1993), resulting in 39,832 sentences for training, 1,700 for development, and 2,416 for testing. For CTB, we follow the split of Zhang and Clark (2008), resulting in 16,091 sentences for training, 803 for development, and 1,910 for testing. For UD2.2, we follow Yang and Tu (2022) and use the standard splits of the following
corpora for experiments: BG-btb, CA-ancora, CSpdt, DE-gsd, EN-ewt, ES-ancora, FR-gsd, IT-isdt, NL-alpino, NO-rrt, RO-rrt, RU-syntagrus.
Licenses. The PTB and CTB datasets are licensed under LDC User Agreement. The UD2.2 dataset is licensed under the Universal Dependencies License Agreement.

heading: F Hyperparameter Settings
text: We use the Python NLTK package to process the datasets, i.e., converting CoNLL-U formatted data to dependency trees, extracting dependency arcs from dependency trees for evaluation, implementing Alg. 1 and 2. For UD, we apply MaltParser v1.9.27 to pseudo-projectivize the non-projective trees (Nivre and Nilsson, 2005).
We use xlnet-large-cased8 for English PTB, chinese-xlnet-mid9 for CTB, and bert-multilingualcased10 for UD.
The dimension of POS tag embedding is set to 256 for all experiments. On top of concatenated pretrained representations and POS embedding, we use a 3-layer BiLSTM with a hidden size of 768 for base-sized models (bert-multilingual-cased on UD) and 1024 for large-sized models (xlnet-large-cased on PTB and chinese-xlnet-mid on CTB).
Dropout layers with a rate of 0.33 are applied after the concatenated embedding layer, between LSTM layers, and before the MLP projection layer to hexatags.
For training, we used AdamW with a learning rate of 2e−5 for pretrained LMs and 1e−4 for POS embedding, BiLSTM, and MLP. The gradient clipping threshold is set to 1.0. The batch size is set to 32.
7http://www.maltparser.org/download.html 8https://huggingface.co/xlnet-large-cased 9https://huggingface.co/hfl/chinese-xlnet-mid
10https://huggingface.co/ bert-base-multilingual-cased
ACL 2023 Responsible NLP Checklist

heading: A For every submission:

heading: 3 A1. Did you describe the limitations of your work?
text: Limitations

heading: 3 A2. Did you discuss any potential risks of your work?
text: Ethics Statement

heading: 3 A3. Do the abstract and introduction summarize the paper’s main claims?
text: Abstract and Sec. 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts?

heading: 5, App. D
text: 3 B1. Did you cite the creators of artifacts you used? 5

heading: 3 B2. Did you discuss the license or terms for use and / or distribution of any artifacts?
text: App D

heading: 3 B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided
text: that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? App D
B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? Not applicable. Left blank.

heading: 3 B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and
text: linguistic phenomena, demographic groups represented, etc.? App D
3 B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. App D
C 3 Did you run computational experiments? 5

heading: 3 C1. Did you report the number of parameters in the models used, the total computational budget
text: (e.g., GPU hours), and computing infrastructure used? App. E
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.

heading: 3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found
text: hyperparameter values? App. E

heading: 3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary
text: statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? 5

heading: 3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did
text: you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? App. F
D 7 Did you use human annotators (e.g., crowdworkers) or research with human participants? Left blank.
D1. Did you report the full text of instructions given to participants, including e.g., screenshots, disclaimers of any risks to participants or annotators, etc.? No response.
D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students) and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? No response.
D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to crowdworkers explain how the data would be used? No response.
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? No response.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? No response.

heading: Future Work
text: We would like to explore the possibility of extending hexatagger to non-projective parsing for future work. Interpretibility. As a trade-off for efficiency, hexatagger does not model dependency arcs directly. Compared to graph-based models that explicitly score arc scores between pairs of words, it is more difficult to interpret the output of hexatagger