Semantic dependency parsing, which aims to find rich bi-lexical relationships, allows words to have multiple dependency heads, resulting in graph-structured representations. We propose an approach to semi-supervised learning of semantic dependency parsers based on the CRF autoencoder framework. Our encoder is a discriminative neural semantic dependency parser that predicts the latent parse graph of the input sentence. Our decoder is a generative neural model that reconstructs the input sentence conditioned on the latent parse graph. Our model is arc-factored and therefore parsing and learning are both tractable. Experiments show our model achieves significant and consistent improvement over the supervised baseline. Semantic dependency parsing (SDP) is a task aiming at discovering sentence-internal linguistic information. The focus of SDP is the identification of predicate-argument relationships for all content words inside a sentence (Oepen et al., 2014, 2015). Compared with syntactic dependencies, semantic dependencies are more general, allowing a word to be either unattached or the argument of multiple predicates. The set of semantic dependencies within a sentence form a directed acyclic graph (DAG), distinguishing SDP from syntactic dependency parsing tasks, where dependencies are usually tree-structured. Extraction of such high-level structured semantic information potentially benefits downstream NLP tasks (Reddy et al., 2017; Schuster et al., 2017). Several supervised SDP models are proposed in the recent years by modifying syntactic dependency parsers. Their parsing mechanisms are either transition-based (Kanerva et al., 2015; Wang et al.,  Corresponding author. 2018) or graph-based (Martins and Almeida, 2014; Peng et al., 2017; Dozat and Manning, 2018; Wang et al., 2019). One limitation of supervised SDP is that labeled SDP data resources are limited in scale and diversity. Due to the rich relationships in SDP, the annotation of semantic dependency graphs is expensive and difficult, calling for professional linguists to design rules and highly skilled annotators to annotate sentences. This limitation becomes more severe with the rise of deep learning, because neural approaches are more data-hungry and susceptible to over-fitting when lacking training data. To alleviate this limitation, we investigate semi-supervised SDP capable of learning from both labeled and unlabeled data. While a lot of work has been done on supervised SDP, the research of unsupervised and semi-supervised SDP is still lacking. Since parsing results of semantic dependencies are DAGs without the tree-shape restriction, most existing successful unsupervised (Klein and Manning, 2004; I. Spitkovsky et al., 2010; Jiang et al., 2016; Cai et al., 2017) and semi-supervised (Koo et al., 2008; Druck et al., 2009; Suzuki et al., 2009; Corro and Titov, 2019) learning models for syntactic dependency parsing cannot be applied to SDP directly and it would be non-trivial to extend these models for SDP. There also exist several unsupervised (Poon and Domingos, 2009; Titov and Klementiev, 2011) and semi-supervised (Das and Smith, 2011; Kocisk`y et al., 2016; Yin et al., 2018) methods for semantic parsing, but these models are designed for semantic representations different from dependency graphs, making their adaptation to SDP difficult. In this work, we propose an end-to-end neural semi-supervised model leveraging both labeled and unlabeled data to learn a dependency graph parser. Our model employs the framework of Conditional Random Field Autoencoder (Ammar et al., 2014), modeling the conditional reconstruction probability given the input sentence with its dependency graph as the latent variable. Our encoder is the supervised model of Dozat and Manning (2018), formulating an SDP task as labeling each arc in a directed graph with a simple neural network. Analogous to a CRF model (Sutton et al., 2012), our encoder is capable of computing the probability of a dependency graph conditioned on the input sentence. The decoder is a generative model based on recurrent neural network language model (Mikolov et al., 2010), which formulates the probability of generating the input sentence, but we take into account the information given by the dependency parse graphs when generating the input. Our model is arc-factored, i.e., the encoding, decoding and reconstructing probabilities can all be factorized into the product of arc-specific quantities, making both learning and parsing tractable. A unified learning objective is defined that takes advantage of both labeled and unlabeled data. Besides, compared with previous semi-supervised approaches based on Variational Autoencoder (Kingma and Welling, 2013), our learning process does not involve sampling, promising better stability. We evaluate our model on SemEval 2015 Task 18 Dataset (English) (Oepen et al., 2015) and find that our model consistently outperforms the supervised baseline. We also conduct detailed analysis showing the benefits of different amounts of unlabeled data. Our model is based on the CRF autoencoder framework (Ammar et al., 2014) which provides a unified fashion for structured predictors to leverage both labeled and unlabeled data. A CRF autoencoder aims to produce a reconstruction of the input X from the original input X with an intermediate latent structure Y . It is trained to maximize the conditional reconstruction probability P (X = X | X) with the latent variable Y marginalized. Ideally, successful reconstruction implies that the latent structure captures important information of the input. We adopt the following notations when describing our model. We represent a vector in lowercase bold, e.g., s , and use a superscript for indexing, e.g., s i for the i -th vector. We represent a scalar in lowercase italics, e.g., s , and use a subscript for indexing, e.g., s i for the i -th element of vector s . An uppercase italic letter such as Y denotes a matrix. A lower case letter with a subscript pair such as y i,j refers to the element of matrix Y at row i and column j . An uppercase bold letter, e.g., U , stands for a tensor. We maintain this convention when indexing, e.g., y i is the i -th row of matrix Y . In our model, the input is a natural language sentence consisting of a sequence of words. A sentence with m words is represented by s = ( s 0 , s 1 , s 2 , . . . , s m ) , where s 0 is a special token TOP. The latent variable produced by our encoder is a dependency parse graph of the input sentence, represented as a matrix of booleans Y  { 0 , 1 } ( m +1)  ( m +1) , where y i,j = 1 indicates that there exists an dependency arc pointing from word s i to word s j . The reconstructed output generated by our decoder is a word sequence  s = ( s 1 ,  s 2 , . . . ,  s m ) . Our encoder with parameters  computes P  ( Y | s ) , the probability of generating a dependency parse graph Y given a sentence s . Our decoder with parameters  computes P  ( s | Y ) , the probability of reconstructing sentence  s conditioned on the parse graph Y . The encoder and decoder in combination specify the following conditional distribution. where Y is the set of all possible dependency parse graphs of s . During training, we set  s = s and maximize the conditional reconstruction probability P ( s | s ) . Note that throughout our model, we only consider dependency arc predictions (i.e., whether an arc exists between each word pair). Arc-labels will be learned separately as described in Section 3. We leave the incorporation of arc-label prediction in our model for future work. Our encoder can be any arc-factored discriminative SDP model. Here we adopt the model of Dozat and Manning (2018), one of the best-performing SDP models, which formulates the semantic dependency parsing task as independently labeling each arc in  Embedding FNN BiLSTM     Biaff  (dep)  (head)        Figure 1: Illustration of the encoder, following the design of Dozat and Manning (2018). a directed complete graph. To predict whether or not a directed arc ( s i , s j ) exists, the model computes contextualized representations of s i and s j and feeds them into a binary classifier. The architecture of our encoder is shown in Figure 1. Word, part-of-speech tag (for short, POS tag), and lemma embeddings 1 of each word in the input sentence are concatenated and fed into a multilayer bi-directional LSTM to get a contextualized representation of the word. where e (word) i , e (tag) i and e (lemma) i are notations for the word, POS tag and lemma embedding respectively, concatenated (  ) to form an embedding x i for word s i . Stacking x i for i = 0 , 1 , . . . , m forms matrix X . The contextualized word representation is then fed into two single-layer feedforward neural networks (FNN) with different parameters to produce two vectors: one for the representation of the word as a dependency head and the other for the representation of the word as a dependent. They are denoted as h (head) i and h (dep) i respectively. Finally, a biaffine function is applied to every arc between word pairs ( s i , s j ) to obtain an arc-existence score  i,j . i,j = h (head) (cid:62) i W h (dep) j + b 1 The latest experimental results in Dozat and Manning (2018) show that using lemma embedding improves performance even further while including character-level word embedding produces little effect. Thus unless stated otherwise, our model makes use of lemma embeddings by default. where W is a square matrix of size d  d ( d is the size of vector h (head) i and h (dep) j ) , and b is a scalar. The likelihood of every arc's presence given a sentence, P ( y i,j = 1 | s ) , can be computed by applying a sigmoid function on score  i,j . The arc-absence probability P ( y i,j = 0 | s ) is evidently 1  P ( y i,j = 1 | s ) . To conclude, the probability of producing a dependency parse graph Y from the encoder given an input sentence s can be computed as below. Our generative decoder is based on recurrent neural network language models (Mikolov et al., 2010), but we take dependency relationships into account during reconstruction. Our inspiration sources from the decoder with a Graph Convolutional Network (GCN) used by Corro and Titov (2019) to incorporate tree-structured syntactic dependencies when generating sentences, but our decoder differs significantly from theirs in that ours handles parse graphs and is arc-factored. As mentioned above, semantic dependency parsing allows a word to have multiple dependency heads. If we generate a word conditioned on multiple heads, then it becomes difficult if not impossible to make the decoder arc-factored and hence we may have to enumerate all parse graphs during parsing and learning, which is intractable. Instead, we propose to generate a word for multiple times, each time conditioned on a different head, which leads to a fully arc-factored generative decoder and hence tractable parsing and learning. Specifi-cally, we split dependency graph Y of a sentence s = ( s 0 , s 1 , . . . , s m ) with m words and a TOP token into m + 1 parts: Y = [ y 0 ; y 1 ; y 2 ; . . . ; y m ] Each y i is the i -th row of Y , representing a subgraph where arcs are rooted at the i -th word of the sentence s . Mathematically, we have y i = { y i,j | j  (1 , 2 , ..., m ) } . We then generate m + 1 sentences ( s 0 ,  s 1 ,  s 2 , . . . ,  s m ) using m + 1 neural generators. The generation of sentence  s i is guided by the i -th sub-graph y i . Each generator is a left-to-right LSTM language model and computes P  ( s ki |  s k 0: i  1 , y k,i ) , the probability of generating  ! We share parameters among all the m + 1 generators. Figure 2 shows an example for computing the generative probability of  s k by the k -th generator ( k  { 0 , 1 , . . . , m } ) that incorporates the information of the k -th sub-graph y k . Recall that y k contains only dependencies rooted at s k . Below we describe how to compute the generative probability of each word  s ki with and without the dependency arc ( s k , s i ) respectively. Generative probability with a dependency Suppose there is a dependency arc from s k to s i , we need to compute the generative probability P  ( s ki |  s k 0: i  1 , y k,i = 1) . The LSTM in the k -th generator takes the embedding of the previous word s i  1 computed through Eq.1 as its input and outputs the hidden state g i  1 , which is fed into an FNN to produce a representation m (pre) i  1 . Meanwhile, the embedding of the k -th word (also computed through Eq.1) is fed into another FNN to get its representation m (head) k as a dependency head. G = LSTM ( X ) m (pre) i  1 = FNN (dec  pre) ( g i  1 ) (2) m (head) k = FNN (dec  head) ( x k ) (3) m (head) k and m (pre) i  1 are fed into a bilinear function to obtain a vocabulary-size score vector  ki . Here, U is a tensor of size d  V  d , where V is the vocabulary size and d is the size of vector m (head) k and m (pre) i  1 . To conserve parameters, the tensor U is diagonal (i.e., u i,k,j = 0 wherever i (cid:54) = j ). A softmax function can then be applied to  ki , from which we pick the generative probability of  s ki . Generative probability without a dependency Suppose there is no dependency arc from s k to s i . In this case, reconstruction of  s ki resembles a normal recurrent neural network language model. The representation m (pre) i  1 from Eq.2 is fed into a fully connected layer to get   ki , a vector of vocabulary size containing generative scores of all the words. The generative probability P  ( s ki |  s k 0: i  1 , y k,i = 0) can then be computed by applying a softmax function on   ki and selecting the corresponding probability of  s ki . Since we simply reconstruct word s i without considering the dependency arc information, this probability is exactly the same in the m + 1 generators and only needs to be computed once. To conclude the overall design of our decoder, it is worth noting that in m + 1 generation processes, parameters among all LSTMs are shared, as well as those among all FNNs 2 and FCs. Still, embeddings in Eq.1 are shared among both encoder and decoder. With P ( s ki |  s k 0: i  1 , y k,i ) computed for i = 1 , . . . , m , k = 0 , 1 , . . . , m , the probability of generating  s 0 ,  s 1 ,  s 2 , . . . ,  s m from dependency graph Y can be computed through: P  ( s 0 , . . . ,  s m | Y ) = m (cid:89) k =0 P  ( s k | y k ) = m (cid:89) k =0 m (cid:89) i =1 P  ( s ki |  s k 0: i  1 , y k,i ) In our model, we are only interested in the case where all the m + 1 sentences are the same. In addition, to balance the influence of the encoder and the decoder, we take the geometric mean of the m + 1 probabilities. The final decoding probability is defined as follows. 2 FNN (dec  pre) and FNN (dec  head) never share parameters between each other, since their usages are different. Given parameters {  ,  } of our encoder and decoder, we can parse a sentence s by finding a Y  Y ( s ) which maximizes probability P ( s = s , Y | s ) , where Y ( s ) is the set of all parse graphs of sentence s . = arg max Y Y ( s ) log P  ,  ( s , Y | s ) (6) = arg max Y Y ( s ) log P  ( Y | s ) P  ( s | Y ) = arg max Y Y ( s ) (cid:88) i,j (cid:16) log P  ( y i,j | s ) + 1 m + 1 log P  ( s j |  s 0: j  1 , y i,j ) (cid:17) Since the probability is arc-factored, we can determine the existence of each dependency arc independently by picking the value of y i,j that maximizes the corresponding term. The time complexity of our parsing algorithm is O ( m 2 ) for a sentence with m words. Since we want to train our model in a semi-supervised manner, we design loss functions for labeled and unlabeled data respectively. For each training sentence s , the overall loss function is defined as a combination of supervised loss L l and unsupervised loss L u . Supervised Loss For any labeled sentence ( s , Y  ) , where s stands for a sentence and Y  stands for a gold parse graph, we can compute the discriminative loss. L l ( s ) =  log P  ,  ( s = s , Y  | s ) (8) Following the derivation of Eq.6, we have: log P  ,  (  s , Y  | s ) = (cid:88) i,j (cid:16) log P  ( y  i,j | s ) + 1 m + 1 log P  ( s j |  s 0: j  1 , y  i,j ) (cid:17) Usage Source Sentences Tokens train WSJ Sec.00-20 35,656 802,717 test (id) WSJ Sec.21 1,410 31,948 test (ood) Brown 1,849 31,583 Table 1: The sources and scale of the SDP 2014 & 2015 (English) dataset. Gold parses also provide a label for each dependency. We follow Dozat and Manning (2018) and model dependency labels with a purely supervised module on top of the BiLSTM layer of the encoder. Its parameters are learned by optimizing a cross-entropy loss function. Unsupervised Loss For any unlabeled sentence s , we maximize the conditional reconstruction probability P (  s = s | s ) . The unsupervised loss is: L u ( s ) =  log P  ,  ( s | s ) (9) =  log (cid:88) Y Y ( s ) P  ,  ( Y,  s | s ) =  log (cid:88) Y Y ( s ) P  ( Y | s ) P  ( s | Y ) =  (cid:88) i,j log (cid:88) y i,j { 0 , 1 } (cid:16) P  ( y i,j | s )  m +1 (cid:113) P  ( s j |  s 0: j  1 , y i,j ) (cid:17) Derivations of Eq.9 are provided in the Appendix A. Given a dataset containing both labeled and unlabeled sentences, our model can be trained end-to-end by optimizing the loss function Eq.7 over the combined dataset using any gradient based method. Dataset We examine the performance of our model on the English corpus of the SDP 2014 & 2015: Broad Coverage Semantic Dependency Parsing dataset (Oepen et al., 2015). The corpus is composed of three distinct and parallel semantic dependency annotations (DM, PAS, PSD) of Sections 00-21 of the WSJ Corpus, as well as a balanced sample of twenty files from the Brown Corpus. The scale of this dataset is shown in Table 1. Hidden Layer Hidden Sizes Word/GloVe/POS/Lemma/Char 100 GloVe Linear 125 Encoder BiLSTM 3*600 Encoder FNN(head) 1*600 Encoder FNN(dep) 1*600 Decoder UniLSTM 1*600 Decoder FNN(head) 1*400 Decoder FNN(pre) 1*400 Dropouts Dropout Prob. We evaluate the performance of models through two metrics: Unlabeled F1 score (UF1) and Labeled F1 score (LF1). UF1 measures the accuracy of the binary classification of arc existence, while LF1 measures the correctness of each arc-label as well. Unless stated otherwise, we report scores averaged over three runs. Network Configuration For our encoder, we adopt the hyper-parameters of Dozat and Manning (2018). Following Dozat and Manning (2018), we concatenate pre-trained 100-dimensional GloVe embeddings (Pennington et al., 2014) linearly transformed to 125-dimension into our input word embeddings. Words or lemmas whose occurrences are less than 7 times within the training set are treated as UKN. For our decoder, we set the number of layer(s) of uni-directional LSTM to 1, whose recurrent hidden size is 600. For FNN (dec  head) and FNN (dec  pre) , the output sizes are both 400, activated by a tanh (  ) function. Learning Our loss function (Eq.7) is optimized by the Adam+AMSGrad optimizer (Reddi et al., 2018), with hyper-parameters  1 ,  2 kept the same as those of Dozat and Manning (2018). The interpolation constant  is tuned with the size of unlabeled data. A detailed table of hyper-parameters is provided in Table 2. The training time for one batch with our autoencoder is 23 times of that of Dozat and Manning (2018) because of the extra decoder. In our first experiment (with the DM annotations only), we fix the amount of labeled data and continuously incorporate more unlabeled data into the training set. Specifically, we randomly sample 10% of the whole dataset as labeled data. Unlabeled data are then sampled from the remaining part (with their gold parses removed), with a proportion increasing from 0% to 90% of the complete dataset. For unlabeled data, we find that long sentences do not help in improving F1 scores and therefore in this and all the subsequent experiments we remove unlabeled sentences longer than 20 to reduce the running time and memory usage. Experimental results are visualized in Figure 3. It is observed that in the purely supervised setting (i.e., +0% unlabeled data), our model already outperforms the baseline (Dozat and Manning, 2018). Since our encoder is exactly the baseline model, this shows the benefit of adding the decoder for joint learning and parsing even in the supervised setting. With an increasing size of unlabeled data, we can see the increase in performance of our model, especially when evaluated on out-of-domain data, suggesting the benefit of semi-supervised learning with our model. In our second experiment (again with the DM an-notations), we use the full training set and vary the proportion of labeled and unlabeled data. Experimental results are shown in Table 3. Our semi-supervised model shows the largest advantage over the supervised models with the 0.1:9.9 proportion (which contains only 339 labeled sentences), Models Labeled:Unlabeled 0.1:9.9 1:9 3:7 5:5 10:0 UF1 LF1 UF1 LF1 UF1 LF1 UF1 LF1 UF1 LF1 id D&M 75.21 70.70 88.32 86.60 91.65 90.52 92.81 91.90 94.11 93.38 Ours-Sup 75.52 70.59 88.58 86.74 91.88 90.73 92.99 92.05 94.30 93.55 Ours-Semi 76.73 72.16 88.98 87.11 92.04 90.92 93.02 92.07 -ood D&M 70.51 65.63 83.15 80.87 86.91 85.17 88.35 86.93 90.01 88.87 Ours-Sup 70.53 65.48 83.33 80.92 87.16 85.45 88.63 87.24 90.22 89.05 Ours-Semi 72.18 67.30 83.93 81.48 87.43 85.70 88.67 87.28 -Table 3: Experimental results with varying proportions of labeled and unlabeled data. With the increased proportion of labeled data, the performance of all the models goes up, but the advantage of our semi-supervised model diminishes. This is consistent with the tendency of many semi-supervised approaches to work well when given small labeled data but have diminishing effectiveness when adding more labeled data. Another worth-noting observation is that the superiority of our semi-supervised model is much stronger on the out-of-domain tests, which suggests good generalizability of our semi-supervised model. In the previous two experiments, we evaluate our model on the DM representation. Here we evaluate our model on all the three representations: DM, PAS and PSD. We slightly tune the hyper-parameters based on the optimal values from the previous experiments of the DM representation. We use 10% of the sentences as labeled data and the rest 90% of the sentences as unlabeled data. For the completeness of our experiment, we follow Dozat and Manning (2018) and examine four different word representations: basic (i.e., using only word and POS tag embeddings), +Lemma (i.e., using word, POS tag and lemma embeddings), +Char (i.e., using word, POS tag and character embeddings) and +Lemma+Char (i.e. using word, POS tag, lemma and character embeddings). Table 4 shows the experimental results of +Lemma , the default word representation. The results of the other word representations show very similar trends (see the Table 7 in Appendix B). We observe significant improvement of our semi-supervised model over the two supervised baselines on both DM and PSD representations. However, it is surprising to find that on the PAS representation, our semi-supervised model exhibits little advantage over its supervised counterpart. One possible explanation, as Dozat and Manning (2018) also noted, is that PAS is the easiest of the three representations (as can be seen by comparing the scores of the three representations in Table 4) and our supervised model may already reach the performance ceiling. We empirically study alternative structures of our decoder. In the first variant, we remove the LSTM layer of our decoder, so each word s i is generated without access to the generation history before s i  1 . In the second variant, we replace the bilinear function in Eq.4 with a fully connected layer that takes as input either the concatenation or the summation of m (head) k and m (pre) i  1 . All the other settings are the same as in Section 4.4 on the DM annotation. Experimental results are shown in Table 5. We can see that these alternatives lead to worse scores, which verifies the effectiveness of our decoder design. To test the stability of our model, we repeat the experiment of Section 4.4 on the DM annotation for three times (without tuning hyper-parameters), each time with respect to different labeled data sampled from the training dataset. Table 6 shows the results. We observe consistent advantage of our Models DM PAS PSD Avg UF1 LF1 UF1 LF1 UF1 LF1 UF1 LF1 id D&M 88.32 86.60 91.89 90.57 88.17 73.42 89.46 83.53 Ours-Sup 88.58 86.74 92.14 90.91 88.49 73.34 89.74 83.66 Ours-Semi 88.98 87.11 92.07 90.84 88.62 73.68 89.89 83.88 ood D&M 83.15 80.87 88.34 86.32 85.10 71.30 85.53 79.50 Ours-Sup 83.33 80.92 88.57 86.68 85.09 71.11 85.66 79.57 Ours-Semi 83.93 81.48 88.61 86.68 85.30 71.46 85.95 79.87 Table 4: Experimental results on all the three representations. Work on unsupervised or semi-supervised dependency parsing, to the best of our knowledge, is dominated by tree-structured parsing (Koo et al., 2008; Druck et al., 2009; Suzuki et al., 2009). Recently, Corro and Titov (2019) introduced an approximate inference method with a Variational Autoencoder (Kingma et al., 2014) for semi-supervised syntactic dependency parsing. Our decoder is inspired by their work, but differs from theirs in that our decoder handles parse graphs and is arc-factored. Cai et al. (2017) used the framework of CRF Autoencoder (Ammar et al., 2014) to perform unsupervised syntactic dependency parsing. The same framework has been used by Zhang et al. (2017) for semi-supervised sequence labeling. Our work also adopts the CRF Autoencoder framework, but with both the encoder and the decoder redesigned for semantic dependency parsing. Existing unsupervised and semi-supervised approaches to semantic parsing focused on semantic representations different from dependency graphs, e.g., general-purpose logic forms (Sondheimer and Nebel, 1986) and formal meaning representations (Bordes et al., 2012). Poon and Domin-gos (2009) presented the first unsupervised semantic parser to transform dependency trees into quasi-logical forms with Markov logic. Following this work, Titov and Klementiev (2011) proposed a non-parametric Bayesian model for unsupervised semantic parsing using hierarchical Pit-manYor process (Teh, 2006). Das and Smith (2011) described a semi-supervised approach to frame-semantic parsing. Kocisk`y et al. (2016) proposed a semi-supervised semantic parsing approach making use of unpaired logical forms with sentence being unobserved. Recently, Yin et al. (2018) proposed a variational autoencoding model for semi-supervised semantic parsing of tree-structured semantic representations. Take Yin et al. (2018) for example. To extend their approach for SDP, one needs to design a different transition system for their encoder for graph parsing and design a graph linearization method for their sequence-to-sequence decoder. In addition, SDP-specific constraints (e.g., the graph structure contains exactly the same set of words as the sentence) shall be incorporated into their model. Therefore, previous semi-supervised semantic parsing models cannot be applied to SDP directly and modifying them for SDP is non-trivial. We leave for future work such modification and extension of previous semi-supervised semantic parsing approaches to SDP. In this work, we proposed a semi-supervised learning model for semantic dependency parsing using CRF Autoencoders. Our model is composed of a discriminative neural encoder producing a dependency graph conditioned on an input sentence, and Models Data1 Data2 Data3 Avg UF1 LF1 UF1 LF1 UF1 LF1 UF1 LF1 id D&M 88.25 86.55 88.70 87.09 88.49 86.85 88.48 86.83 Ours-Sup 88.68 86.84 88.79 86.96 88.71 86.97 88.73 86.92 Ours-Semi 88.95 87.07 89.24 87.45 88.97 87.19 89.05 87.24 ood D&M 83.12 80.89 83.30 81.01 83.62 81.26 83.35 81.05 Ours-Sup 83.36 80.98 83.46 81.05 84.00 81.62 83.60 81.22 Ours-Semi 83.94 81.55 83.87 81.51 84.11 81.68 83.97 81.58 Table 6: Experimental results on three randomly sampled datasets. a generative neural decoder for input reconstruction based on the dependency graph. The model works in an arc-factored fashion, promising end-to-end learning and efficient parsing. We evaluated our model under both full-supervision settings and semi-supervision settings. Our model outperforms the baseline on multiple target representations. By adding unlabeled data, our model exhibits further performance improvements. In particular, our semi-supervised model performs well in the low resource setting and on the out-of-domain test set. This points to future directions of applying our model to low-resource languages and cross-domain settings. Our code is publicly available at https://github.com/JZXXX/Semi-SDP . This work was supported by the National Natural Science Foundation of China (61976139).
abstain objective method abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain other abstain objective method method method method abstain abstain method result result method abstain abstain abstain method method method abstain abstain abstain abstain abstain abstain method method method method abstain abstain abstain method abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain method abstain method abstain method abstain abstain abstain abstain abstain method method abstain abstain abstain abstain abstain method abstain abstain abstain abstain method abstain abstain method method abstain abstain abstain other abstain abstain method abstain method method abstain method abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result result result result abstain result abstain abstain abstain abstain abstain abstain abstain other abstain abstain result result result abstain abstain abstain abstain abstain result abstain abstain result abstain other objective other other method other other abstain other other other other other other other abstain objective result abstain abstain method result method method method other other