A main difference is that while they model P(r|i, j), we model P(i, j|r).

while their model seeks to select an appropriate label for each span (label selection), our model seeks to select appropriate spans for each label (span selection).


As the base feature function f base (Eq.

4 in Section 2.3), we use BiLSTMs, we use the stacked BiLSTMs in an interleaving fashion (Zhou and Xu, 2015;.


In this paper, we propose SyntaxSQLNet, a SQL specific syntax tree network to address the aforementioned task.

to generate complex SQL queries with multiple clauses, selections and sub-queries, we develop a syntax treebased decoder with SQL generation path history.


A square symbol indicates a module that predicts the next SQL token from its corresponding token instances with the same color.


To address this setting, we propose to use both table and column names to construct column embeddings.

given a database, we first obtain embedding for each table by taking the average embedding of the words constituting the table name (e.g., for table name student id, we average the word embeddings for student and id).


Once we have the one-to-one slot mapping between questions and SQL queries, we apply a script that takes a new database schema with type information and generates new question-SQL examples by filling empty slots.

for each database in WikiSQL, we first randomly sam-ple 10 question-SQL patterns.


As the dataset and task definition used in this work are fundamentally different from prior work using datasets such as GeoQuery, WikiSQL, we adapted these models to our task in the same way as (Yu et al., 2018b).

: Seq2Seq with Attention or Copying In order to make the models aware of the table schema information, Yu et al.


Even though our individual modules are similar to SQLNet and TypeSQL, our syntax-aware decoder allows the modules to incorporate the SQL decoding history, which helps to achieve a significant gain in exact matching for queries of all hardness levels.

even without our data augmentation technique, SyntaxSQLNet outperforms the previous best, TypeSQL, by 5%.


For the detailed component matching results in Table 2, our model consistently outperforms other previous work by significant margins.

our model improve F1 score for most of the SQL components by more than 10%.


We use Metropolis Hastings to sample from the posterior over logical forms, using one of the parser models as the proposal distribution.

if we choose the feedback parser as the proposal distribution, and initialize the Markov Chain with a logical form sampled from the task parser, it can be shown that the acceptance probability r for the first sample conveniently simplifies to the following expression: whereŷ t andŷ f are logical forms sampled from the task and feedback parsers respectively.


At each time step j, it generates y j based on the current LSTM hidden state s j , a summary of the input context c j , and attention scores a ji , which are used for attention-based copying as in (Jia and Liang, 2016).

where y j = w denotes that y j is chosen from the output vocabulary V out ; y j = u i denotes that y j is a copy of u i ; a ji = s T j W a h i is an attention score on the input word is a context vector that summarizes the encoder states; and W o and W a are matrix parameters to be learned.


In this paper, we aim to figure out the level of language understanding required to perform well on the WikiSQL task.

we focus on the WHERE clause generation, which is the most challenging part of this task as reported in (Xu et al.


On the other hand, UPPERBOUND accuracy is computed by assuming f cond and f op makes 100% correct mapping of whether to include a candidate (COLUMN, VALUE) pair and which OP to apply on this condition.

errors in UPPER-BOUND exist due to wrong candidate generation.


While the literal usage metric captures the distributional semantic information of the context, we find that some other linguistic cues are also significant for usage detection (such as whether the subject of the sentence is a person); therefore, we allow our model to further refine through unsupervised methods.

we treat the usage (figurative or literal) as a hidden variable in probabilistic latent variable models, and we define a set of features that are linguistically relevant for idiom usage detection as observables.


We propose a metric based on the principle of Minimum Variance (MinV).

we first sort the scores in S and choose the threshold (from these scores) that minimizes the sum of variances of the two resulting clusters.


Second, we explore using the information from the literal usage metric as "noisy gold standard" to perform supervised training on a nearest neighbors (NN) classifier.

the literal and figurative instances labeled by MinV with high confidence (top 30%) are used as example set.


Although these negative results point to the inadequacy of the evaluation test, they also stress a necessary critical analysis of the sense-specific vectors.

they give rise to the following question: why might previously reported polysemic representations show superior performance in these inadequate evaluation tests?


This distance is the basis of all word similarity tasks that serve to evaluate performance, and thus it may provide a partial explanation for the empirical findings, under the assumption that words are better represented as a population of vectors.

the true source of the reported performance gains may be an artifact of a purely statistical benefit that derives from the assignment of words to particular senses, or separate sub-samples, which subsequently reduces the bias of the similarity estimator.


In line with the assumption discussed above, one would predict that the rankorder similarity produced by the sense-specific vectors should outperform the one produced by the global vectors.

more accurate sense-specific vectors should produce better results in these tasks; conversely, better performance on these tasks is interpreted as indicating that polysemy has been captured more accurately.


The results demonstrated in Figure 2 can be described as a negative image of those presented in Figure 1.

the actual gain condition of the induced-polysemy has the largest polysemic signature as compared to the other conditions.


Here we investigate the common-held view that polysemy representation improves performance.

we question the validity of word similarity tasks as a suitable evaluation test that would allow drawing such conclusions.


Given a pair of adjectives to be ranked by their intensity, de Melo and Bansal (2013) cull intensity patterns from Google n-Grams (Brants and Franz, 2009) as evidence of their intensity order.

they identify 8 types of weak-strong patterns (e.g.


The performance trends on the deMelo dataset differ from those on the Crowd and Wilkinson datasets.

score pp and score socal have substantially lower pre-ranking pairwise accuracy on the pairs they cover in the deMelo dataset than they do for Crowd and Wilkinson: score pp has an accuracy of just 0.458 on covered pairs in the deMelo dataset, compared with 0.676 and 0.753 on the Crowd and Wilkinson datasets, and score differences for score socal are similar.


Future Work Using the PHSIC estimator in feature space (Equation 18), we can generate the most appropriate ψ(y) for a given φ(x) (uniquely, up to scale).

if a DNN-based sentence decoder is used, y (a sentence) can be restored from ψ(y) (a feature vector) so that generative models of strong co-occurring sentences can be realized.


On this basis, a well-performing algorithm node2vec (Grover and Leskovec, 2016) is adopted to conduct an unsupervised random walk to vectorize every node ∀v * ∈ V into a d-dimensional embedding ϕ(v * ) ∈ R d so that any edge ∀e * ∈ E can be calculated therefrom.

we employ evolutionary algorithm (EA) to tune the EUD, which enjoys advantages over conventional gradient methods in both convergence speed and accuracy.


Hierarchical Encoder Our encoder consists of two major layers, namely a convolutional neural network (CNN) and a long-short-term memory (LSTM)-based RNN.

the CNN deals with word-level texts to derive sentencelevel meanings, which are then taken as inputs to the RNN for handling longer-range dependency within lager units like a paragraph and even a whole paper.


As shown in Figure 2 (top), the binary decision y t j is made by both the hidden state h t j and the context vectorh t j from an attention mechanism (grey background).

this attention (red dash line) is acted as an intermediate stage to determine which sentences to highlight so as to provide the contextual information for current decision (Bahdanau et al., 2014).


To create training data for our summarizer, each reference needs to be annotated with the ground truth in advance, i.e., candidate sentences are tagged with 0/1 for indicating summary-worthy or not.

we follow a heuristic practice of Cao et al.


Evaluation We adopt the widely used toolkit ROUGE (Lin and Hovy, 2003) to evaluate the summarization performance automatically.

we report ROUGE-1 and ROUGE-2 (unigram and bigram overlapping) as a way to assess the informativeness, and ROUGE-L (the longest common subsequence) as a means to assess the fluency, in terms of fixed bytes of gold standards.


In this paper, we propose to extend the basic neural encoding-decoding framework with an information selection layer to explicitly model and optimize the information selection process in abstractive document summarization.

our information selection layer consists of two parts: gated global information filtering and local sentence selection.


Our extreme summarization dataset (which we call XSum) consists of BBC articles and accompanying single sentence summaries.

each article is prefaced with an introductory sentence (aka summary) which is professionally written, typically by the author of the article.


2015to create a large-scale dataset for extreme summarization.

we collected 226,711 Wayback archived BBC articles ranging over almost a decade (2010 to 2017) and covering a wide variety of domains (e.g., News, Politics, Sports, Weather, Business, Technology, Science, Health, Family, Education, Entertainment and Arts).


We adapt this model to our summarization task by allowing it to recognize pertinent content (i.e., by foregrounding salient words in the document).

we improve the convolutional encoder by associating each word with a vector representing topic salience, and the convolutional decoder by conditioning each word prediction on the document topic vector.


We focus on developing a summarization model that produces an increased level of abstraction.

the model produces concise summaries without only copying long passages from the source document.


10 with In order to produce an abstractive summary, the model cannot exclusively copy from the source document.

the model needs to parse large chunks of the source document and create concise summaries using phrases not in the source document.


To further understand the content selection process, we also explore other domains of summarization.

we explore personal narrative summarization based on stories shared on Reddit (Ouyang et al., 2017), workplace meeting summarization (Carletta et al., 2005), and medical journal article summarization (Mishra et al., 2014).


We model the sentence extraction task as a sequence tagging problem, following (Conroy and O'Leary, 2001).

given a document containing n sentences s 1 , .


Given network G, with the network embedding we seek to encode each vertex into a low-dimensional vector h (with dimension much smaller than N ), while preserving structural and semantic features of G. To incorporate both structural and semantic information into the network embeddings, we specify two types of (latent) embeddings: (i) h s , the structural embedding; and (ii) h t , the textual embedding.

each vertex in G is encoded into a low-dimensional embedding h = [h s ; h t ].


Further, the word-by-context embedding for sequence t a is obtained by taking the weighted average over all word embeddings Intuitively, α i may be understood as the relevance score between the ith word in t a and sequence t b .

keywords within t a , in the context of t b , should be assigned larger weights, while less important words will be correspondingly downweighted.


Thus, matrix X b ∈ R d×Ma in (10) constitutes an attention-weighted embedding for X b .

the i-th column of X b , denoted as x b , can be understood as a weighted average over all the words in t b , where higher attention weights indicate better alignment (match) with the i-th word in t a .


In contrast to traditional CNNs, the convolution operation in our framework does not have a fixed set of filters, and thus provides the network with stronger modeling flexibility and capacity.

we introduce a meta network to generate a set of contextaware filters, conditioned on specific input sentences; these filters are adaptively applied to either the same (Section 3.2) or different (Section 3.3) text sequences.


On top of this hidden representation z, a deconvolutional layer, which performs transposed operations of convolutions (Radford et al., 2016), is further applied to produce a unique set of filters for X (as illustrated in Figure 1): where θ e and θ d are the learned parameters in each layer of the filter-generating module, respectively.

we convolve z with a filter of size (f s , l, k x , k y ), where f s is the number of generated filters and the kernel size is (k x , k y ).


The two sets of filter weights are then passed to adaptive convolution modules, along with Q and A, to obtain the extracted question and answer embeddings.

the question embedding is convolved with the filters produced by the answer and vise versa (ψ q and ψ a are the bias terms to be learned).


Datasets We investigate the effectiveness of the proposed ACNN framework on both document classification and text sequence matching tasks.

we consider two large-scale document classification datasets: Yelp Reviews Polarity, and DBPedia ontology datasets (Zhang et al., 2015).


ment's terms (d-terms) and their scores are aggregated to produce a relevance score for the document.

we use the Deep Relevance Matching Model (DRMM) of Guo et al.


As is common for CNNs and even recent RNN term encodings (Peters et al., 2018), we use the original term embedding e(t i ) as a residual and combine it with the BILSTM encodings.

if are the last layer's hidden states of the left-to-right and right-to-left LSTMs for term t i , respectively, then we set the context-sensitive term encoding as: Since we are adding the original term embedding to each LSTM hidden state, we require the dimensionality of the hidden layers to be equal to that of the original embedding.


Steps beyond this constraint include using small amounts of parallel data (Zhang et al., 2016) or an unsupervised technique as the initial step to generate pseudo-parallel data (Conneau et al., 2018) before solving for P. Optimal transport formalizes the problem of finding a minimum cost mapping between two point sets, viewed as discrete distributions.

we assume two empirical distributions over embeddings, e.g., where p and q are vectors of probability weights associated with each point set.


The Gromov-Wasserstein distance (Mémoli, 2011) generalizes optimal transport by comparing the metric spaces directly instead of samples across the spaces.

this framework operates on distances between pairs of points calculated within each domain and measures how these distances compare to those in the other domain.


In this paper, we propose deep probabilistic logic (DPL) as a unifying framework for indirect supervision (Figure 1).


Inference with high-order factors of large size can be challenging, but there is a rich body of literature for handling such structured factors in a principled way.

in distant supervision denoising, we alter the message passing schedule so that each at-least-one factor will compute messages to its variables jointly by renormalizing their current marginal probabilities with noisy-or (Keith et al., 2017), which is essentially a soft version of dual decomposition (CarøE and Schultz, 1999).


The key to practical adoption is attaining high recall with reasonable precision (Peng et al., 2017   subsection, we consider replacing the entity filter by the DPL entity linker Table 7.

we added one labeling function to check if the entity linker returns a normalized probability score above p TRN for gene mentions, and filtered test instances if the gene mention score is lower than p TST .


To make these models applicable in low-resource scenarios, we utilize this connection in the opposite direction.

we propose an approach to map human rationales to high-performing attention, and use this attention to guide models trained in low-resource scenarios.


In this paper, we show how to achieve this goal using rationales.

we learn a mapping from human rationales to high-quality attention (R2A).


For this reason, we ground the encoder by a language modeling component (Bengio et al., 2003;Mikolov et al., 2011).

we employ two Softmax classifiers to predict the word x i based on − → h i−1 and ← − h i+1 respectively.


To obtain an invariant representation, we employ a transformation layer and propose to align the transformed representation so that it is not distinguishable whether it comes from the source or the target.

we transform the representation h i at each position i linearly and obtain where W inv and b inv are learnable parameters.


In order to make predictions for the target task, we train a new classifier under the supervision of both the labels and the R2A-generated attention.

this target classifier shares the same architecture as the source one in the multi-task learning module.


We consider a classification setting for each target task.

reviews with ratings ≤ 0.4 are labeled as negative and those with ≥ 0.6 are labeled as positive.


Transfer methods We compare against two variants of our method: 1) TRANS, an attentionbased classifier that does not use human rationales from the target task; 2) RA-TRANS, an attentionbased classifier that directly uses human rationales to supervise the attention.

tRANS only optimizes the cross-entropy loss L t lbl in the objective (Eq.


It closely matches the performance of OR-ACLE with only 0.40% absolute difference.

all rationale-augmented methods (RA-SVM, RA-TRANS and OURS) outperform their rationale-free counterparts on average.


In this paper, we propose a novel approach that utilizes the connection between human rationales and machine attention to improve the performance of low-resource tasks.

we learn a transferrable mapping from rationales to high-quality attention on resource-rich tasks.


We combine the supervised and CVT losses into the total loss, L = L sup + L CVT , and minimize it with stochastic gradient descent.

we alternate minimizing L sup over a minibatch of labeled examples and minimizing L CVT over a minibatch of unlabeled examples.


Typed directed edges connect the words, forming a tree structure describing the syntactic structure of the sentence.

each word x t i in a sentence x T i receives exactly one in-going edge (u, t, r) going from word x u i (called the "head") to it (the "dependent") of type r (the "relation").


Each example consists of an input (source) sequence The encoder's representations are passed into an LSTM decoder using a bilinear attention mechanism .

at each time step t the decoder computes an attention distribution over source sequence hidden states as α j ∝ e h j Wαh t whereh t is the decoder's current hidden state.


outperforming ELMo embeddings and sometimes even a vanilla supervised model, showing the multi-task model is building up effective representations for language.

the representations could be used like skip-thought vectors (Kiros et al., 2015) to quickly train models on new tasks without slow representation learning.


Early approaches to deep semi-supervised learning pretrain neural models on unlabeled data, which has been successful for applications in computer vision (Jarrett et al., 2009;LeCun et al., 2010) and NLP.

noteworthy for NLP are algorithms for learning effective word embeddings (Collobert et al., 2011;Mikolov et al., 2013;Pennington et al., 2014) and language model pretraining (Dai and Le, 2015;Ramachandran et al., 2017;Peters et al., 2018;Howard and Ruder, 2018;Radford et al., 2018).


Multi-view learning on data where features can be separated into distinct subsets has been well studied (Xu et al., 2013).

relevant are co-training (Blum and Mitchell, 1998) and co-regularization (Sindhwani and Belkin, 2005), which trains two models with disjoint views of the input.


: Gibbs Sampling, Hamiltonian Monte Carlo), VI is deterministic, fast, and benefits from a clear convergence criterion (Blei et al., 2017).

we approximate the intractable posterior p(θ|D) with a variational distribution q(θ) such that the Kullback-Leibler (KL) divergence between the two distributions is minimized.


Based on embeddings bridging, we apply our deterministic algorithm with small adaptations to resolve bridging anaphors to entity antecedents on the BASHI and ARRAU (RST) corpora.

for the BASHI corpus, we do not add NPs from the first sentence to the list of antecedent candidates E a .


Augmenting the query set with WordNet We use WordNet (Kilgarriff, 2000) to construct an augmented query set that contains synonyms for the verbs and adjectives involved in a representation.

we include the synonyms listed for the top synset of the same part of speech as the extracted verb or adjective.


To map each coreferring entity in the snippet to E 1 , E 2 , or E 3 (corresponding loosely to context subject, context object, and query entity, respectively), we consider their position relative to the predicates in the original Winograd instance.

e 1 precedes T erm C , e 2 succeeds T erm C , and e 3 may precede or succeed T erm Q depending on the Winograd instance.


Because entities in the candidate sentences can contribute to the answer (unlike in the WSC), we modified the query generation rules to extract more than just predicates.

the extraction procedure uses the syntactic parse tree of the phrase to back-off from extracting the clause containing the subject and verb phrase, to only the verb phrase, to only the verbs or adjectives that are rooted in the verb phrase.


Our architecture needs to explicitly take into account the fact that the task at hand is very sen- sitive to lexical ambiguity.

while it is true that the level of homonymy (words having more than one disjoint meanings) is substantially decreased when we move from the generic domain to more specialised domains, on the other hand the increase in polysemy (words with many slightly different meanings) is exponential.


These sense embeddings can be seen as centroids of clusters denoting different uses of the word in the training set, and are dynamically updated during training.

for each word w i in a training example, a context vector c i is computed as the average of the generic vectors of all other words in the sentence.


Comparisons are provided with the most relevant previous work.

in all tasks, no inclusion of textual features corresponds to the standard DeepWalk model of Perozzi et al.


The last row of the table presents results after extending the training dataset with the textual anchors, that is, all the textual features paired with their learned KB vectors, as described in the Advantages section in §3.1.

recall that each textual feature (a word or a two-word compound), being also a node in the graph, is associated with a vector according to the process of §3.1.


In this paper, we propose a novel knowledge graph embedding model named TransC by differentiating concepts and instances.

transC encodes each concept in knowledge graph as a sphere and each instance as a vector in the same semantic space.


For each instance i ∈ I and instance relation r ∈ R l , we learn a low-dimensional vector i ∈ R k and r ∈ R k respectively.

the instanceOf and subClassOf representations are well-designed so that the transitivity of isA relations can be reserved, namely, instanceOf-subClassOf transitivity shown in Equation 5: and subClassOf-subClassOf transitivity shown in Equation 6: Based on the definition, how to model concepts and isA relations is critical to solve this problem.


First, as shown in Figure 1, a large portion of KG relations are actually long-tail.


• We draw attention to the important but relatively unexplored problem of temporally aware Knowledge Graph (KG) embedding.

we propose HyTE, a temporally aware method for learning Knowledge Graph (KG) embedding.


Unlike existing approaches, we propose lightweight yet effective methods for performing domain adaptation for neural models.

we introduce adaptation layers on top of existing neural architectures, where no retraining using the source domain data is required.


In this work, we propose solutions to address the above-mentioned issues.

we address the first issue at both the word and sentence level by introducing a word adaptation layer and a sentence adaptation layer respectively, bridging the gap between the two input spaces.


Thus, in this paper, we focus on a new entity linking problem where both the entity mentions and the target entities are within a social media platform.

the entity mentions are from the texts (which we will refer to as mention texts) produced by the users on a social media platform; and these mentions are linked to the accounts on this platform.


We demonstrate that our approach leads to more data being annotated, and better overall performance for the model being learned.

we focus on the task of bootstrapped named entity classification (NEC), where a classifier is trained to label named entities with their corresponding category.


Despite the lower accuracy, the scatterplot interface generally yields better classifiers.

the volume of annotations matters just as much as quality for the classifier performance.


Yet, in this process we would like to minimize human effort while maximizing bootstrapping performance, where we define effort as the total time spent annotating data.

the primary focus of our study is on step (S2), and how the user's interactions with the interface impacts these considerations.


1: list interfaces, and scatterplot interfaces.

both interfaces utilize the state of the model to decide on what to show to the user.


Please note that traditional bootstrapping techniques such as rule-based methods (Collins and Singer, 1999) fail to meet all criteria.

they are not suitable for visual exploration because there is no clear way to represent the semantic proximity of rules or of the concepts being learned.


To adapt to imperfect labels generated by distant supervision, we go beyond the traditional sequence labeling framework and propose a new prediction model.

instead of predicting the label of each single token, we propose to predict whether two adjacent tokens are tied in the same entity mention or not (i.e., broken).


Here, H(p, q) is the cross entropy between p and q, andp(t j |v i , L i ) is the soft supervision distribu-tion.

it is defined as: is the boolean function of checking whether the i-th span candidate is labeled as the type t j in the distant supervision.


When a token span cannot be matched to any entity surface names in the dictionary, because of the limited coverage of dictionaries, it is still difficult to claim it as non-entity (i.e., negative labels) for sure.

some high-quality phrases out of the dictionary may also be potential entities.


Dictionary Match is our proposed distant supervision generation method.

we apply it to the testing set directly to obtain entity mentions with exactly the same surface name as in the dictionary.


To demonstrate the effectiveness of distant supervision, we try to compare our method with gold annotations provided by human experts.

we conduct experiments on the BC5CDR dataset by sampling different amounts of annotated articles for model training.


We create a mapping from each word in the corpus to the relevant concepts associated with it.

the result is a map S from tokens to concepts: S : w → {c, score(c|w)} (see Figure 3), where score(c|w) denotes the association of the word w with concept c, calculated as the sum of the tF-IDF values of the word w in the sentences describing c: we treat each sentence as a document and compute tF-IDF scores for the words in it.


In theory, for a sensible type t, the count of context-consistent concepts that have this type should be higher than that of the initial concept candidates.

count(t;c ELMO )/ ELMO count(t;c ESA )/ ESA > 1.


As mentioned earlier, existing solutions that depend on predefined templates (such as (Xu et al., 2016;Bast and Haussmann, 2015)) or query graph structure patterns (such as (Yih et al., 2015)) may not be suitable due to the diversity of complex questions.

considering the above challenges, we propose a state transition based framework to translate users' question N into a semantic query graph (SQG) Q S , further the answers of N can be found by matching Q S over the knowledge graph G. we first recognize nodes (such as entities and variables) from N as the initial state (Section 2.1).


Each turn we choose the state with maximum correctness likelihood and try all possible transitions by each operation.

the connect and merge operations try every pair of nodes in current state as the two operate nodes, while the expand and fold operations try each node as the operate node.


Given a node phrase in Q S , we find the candidate entities/types with confidence probabilities by using existing entity linking approaches.

we use S-MART (Yang and Chang, 2015) for Freebase dataset and DBpeida Lookup 4 for DBpedia dataset.


In some questions (such as Q66 and Q81), the gap of elapsed time are very little because the number of recognized nodes are less than three.

those simple questions do not need the conditions to speed up the SQG construction process.


For example, such input can be the output of the co-attention layer in Section 3.

the operation of this layer is defined as at time step t, the controller generates an interface vector i t for read and write operations and an output vector o t based on the input vector d t and the external memory content from the previous time step, M t−1 ∈ R p×q , where p is the memory size and q is the vector dimension of each memory.


Our proposed encoder is not only aimed at being fast but also expressive.

the key novelty behind our encoder is that it explicitly models across multiple granularities using a new dilated composition mechanism.


Our proposed encoder leverages dilated compositions to model relationships across multiple granularities.

for a given word in the target sequence, our encoder exploits both long-term (far) and short-term (near) information to decide how much information to retain for it.


Our approach instead imposes independence assumptions that give a linguistically motivated inductive bias.

it enforces that phrases are interpreted independently of surrounding words, allowing the model to generalize naturally to interpreting phrases in different contexts.


At the same time, within becomes a kernel, which takes the (Q 1 , Q 2 ) or (A 1 , A 2 ) pairs as input.

2 is a sum of products of f i (•, •) kernels applied to the (Q 1 , Q 2 ) and (A 1 , A 2 ) pairs.


for each model, we trained it for 5 independent runs with different seeds, and for each example we evaluated the model's accuracy over these 5 runs.


(2017) such as the source of features and hyper parameter settings.

the full input graph is modeled as a single state, with words in the graph being its sub states.


(2017) formulate the task as a graphstructured problem in order to adopt rich dependency and discourse features.

stanford parser  is used to assign syntactic structure to input sentences, and heads of two consecutive sentences are connected to represent discourse information, resulting in a graph structure.


Our input graph formulation strictly follows Section 3.

our model adopts the same methods for calculating input representation (as in Section 3.1) and performing classification as the baseline model.


Following the approches of  and , a recurrent neural network is utilized to model the state transition process.

the transition from g t 1 to g t consists of hidden state transition for each word, as shown in Figure 2.


In addition to edge inputs, a cell also takes the hidden states of its incoming and outgoing words during a state transition.

the states of all incoming words and outgoing words are summed up, respectively: Based on the above definitions of x i j , x o j , h i j and h o j , the recurrent state transition from g t 1 to g t , as represented by h j t , is defined as: where i j t , o j t and f j t are the input, output and forget gates, respectively.


Graph convolutional networks (GCNs) and very recently graph recurrent networks (GRNs) have been used to model graph structures in NLP tasks, such as semantic role labeling , machine translation (Bastings et al., 2017), text generation ), text representation  and semantic parsing (Xu et al., 2018b,a).

use GRN to represent raw sentences by building a graph structure of neighboring words and a sentence-level node, showing that the encoder outperforms BiLSTMs and Transformer (Vaswani et al., 2017) on classification and sequence labeling tasks; Song et al.


This paper proposes a label-free distant supervision method, which makes no use of the relation labels under this inadequate assumption, but only uses the prior knowledge derived from the KG to supervise the learning of the classifier directly and softly.

we make use of the type information and the translation law derived from typical KG embedding model to learn embeddings for certain sentence patterns.


Unlike prior efforts, we propose a new lightweight joint learning paradigm based on minimum risk training (MRT).

our algorithm optimizes a global loss function which is flexible and effective to explore interactions between the entity model and the relation model.


Third, in addition to handcrafted loss functions, we further ask whether the joint MRT model could benefit from automatic "loss engineering".

let Γ(ŷ) be the loss learned from the training set, we augment ∆(ŷ, y) of the MRT objective with Γ(ŷ), and require the learning process to assign a smaller Γ value (with a margin) to the ground truth output y than otherŷ ∈ Y \{y}, min .


In practice, we could approximate the expectation in Equation 3 by sampling a tractable subset Y ′ (s) of Y(s).

we first obtain an entity set E ′ by sampling (without replacement) an entity tag sequence t ′ from P ent .


using precision (P), recall (R) and F1 scores.

an output entity e is correct if its type and the region of its head are correct, and an output relation r is correct if its e 1 , e 2 , l are correct (i.e., "exact match").


Comparing with the default sampling algorithm, it has similar entity extraction performances, but its behaviour on the relation extraction is different.

adding entity loss in ∆(ŷ, y) (i.e., ∆ E , ∆ E+R ) now affects relation results negatively.


Both NN and MRT outperform    baseline results.

comparing with the joint tagging scheme in (Zheng et al., 2017), MRT adds no constraint on the relation extraction model and can explore the large NYT training set more effectively.


Annotators had to choose from two answers: yes or no, where no indicates all cases in which there is not enough information to determine that a possession relation exists at any point of time before / during / after year.

no does not mean that the potential possessor did not possess the possessee, and it may mean that there is no information about whether a possession relations exists.


We also experimented with modifications of the full neural network to provide insights into which components are more useful.

we report results not using the additional embeddings for the possessor and year, and disabling the LSTMs for the article title and section title.


In this paper, we track possession relations over time.

we work with Wikipedia articles about artworks, and extract their possessors as well as temporal information with respect to the years explicitly mentioned (before, during or after).


The low-level Q-function is learned in a similar way, and follows the standard Q-learning update, except that intrinsic rewards for subgoal g are used.


All these different application scenarios show that users expect to formulate complex information needs in natural language, with no limitation to their expressiveness.

standard shallow semantic parsing based on concept segmentation and labeling is no longer sufficient for dialog modeling in today's applications.


In other words, standard shallow semantic parsing based on concept segmentation and labeling is no longer sufficient for dialog modeling in today's applications.

when designing dialog managers, we need to consider user intents expressed by articulated natural language text.


Intent is a key concept for building dialog systems and is therefore a central research topic in the area.

recent general-purpose dialog systems have to rely on extensive intent modeling to be able to correctly analyze a wide variety of user queries.


Indeed, the important concepts will be learned from the training data, which constitutes a much simpler annotation task than the creation of ad hoc dialogue acts.

this can help with domain-specific intents: the domain-level semantics will be learned from data with no need for advanced manual engineering.


With this motivation, we built a new background aware conversation dataset using crowdsourcing.

we asked workers to chat about a movie using structured and unstructured resources about the movie such as plots, reviews, comments, fact tables (see Figure 1).


Speaker 2(C): Yeah, it was a really great comic book adaptation Speaker 1(N): The movie is a great life lesson on balancing power.

speaker 2(F): my most favorite line in the movie, "With great power comes great responsibility."


To verify this, we conducted a separate human evaluation wherein we asked 15 in-house evaluators to read conversations (without the background resources) from our dataset and rate them on five different parameters.

they were asked to check if the conversations were 1) intelligible: i.e., an average reader could understand the conversation 2) coherent: i.e., there were no abrupt context switches 3) grammatically correct 4) on-topic: i.e., the chat revolved around the concerned movie with digression limited to related movies/characters/actors and 5) natural two-person chats: i.e., the roleplay setup does not make the chat look unnatural.


Going forward, we would like to build models which are a hybrid of span prediction models and generation models.

we would like to build models which can learn to copy a large sequence from the input instead of one word at a time.


In reinforcement learning, we define a reward R(z 1:T ) on the entire sequence of coarse dialogue acts.

we experiment with three reward functions: • Utility is the objective of a self-interested agent.


We combine these rules with a learned manager to fine-tune the dialogue policy.

the dialogue manager predicts the intent from a learned sequence model but fills in the arguments (e.g., price) using rules.


given a parsed training set, each utterance is converted to a template by delexicalizing arguments in its coarse dialogue act.


Next, candidates are ranked by similarity between their context templates and the current dialogue context.

we represent the context d(x t 1 ) as a TF-IDF weighted bag-of-words vector and similarity is computed by a dot product of two context vectors.


In addition, we demonstrate that human-created data is more difficult than automatically-generated data.

it is much easier for the same model to perform well on automatically-generated data.


We hope that CLOTH provides a valuable testbed for both the language modeling community and the machine comprehension community.

the language modeling community can use CLOTH to evaluate their models' abilities in modeling long contexts, while the machine comprehension community can use CLOTH to test machine's understanding of language phenomena.


In order to evaluate students' mastery of a language, teachers usually design tests in a way that questions cover different aspects of a language.

they first identify words in the passage that can examine students' knowledge in vocabulary, logic, or grammar.


Hence, we divided the questions except grammar questions based on the difficulty level for a machine to answer the question, following works on analyzing machine comprehension datasets (Chen et al., 2016;Trischler et al., 2016).

we divide them in terms of their dependency ranges, since questions that only involve a single sentence are easier to answer than questions involving evidence distributed in multiple sentences.


Attentive Readers To enable the model to gather information from a longer context, we aug-ment the supervised LSTM model with the attention mechanism (Bahdanau et al., 2014), so that the representation at the blank is used as a query to find the relevant context in the document and a blank-specific representation of the document is used to score each candidate answer.

we adapt the Stanford Attentive Reader (Chen et al., 2016) and the positionaware attention model (Zhang et al., 2017) to the cloze test problem.


The gap is larger when the LM is trained on the 1 Billion Word Corpus, indicating that more training data results in a better generalization.

the accuracy of 1B-LM is 0.695 when one sentence is used as the context.


To verify this assumption, we compare the LSTM model's performance when given different proportions of the two types of data.

to train a model with α percent of automatically-generated data, we randomly replace a percent blanks with blanks at random positions, while keeping the remaining 1 − α percent questions the same.


(2) Although human-created data may provide more information in distinguishing similar words, the distributional mismatch between two types of data makes it non-trivial to transfer the knowledge gained from human-created data to tackle automatically-generated data.

the model's performance on automatically-generated data monotonically decreases when given a higher ratio of human-created data.


In this section, we propose a model that takes advantage of both sources.

for each question, regardless of being human-created or automatically-generated, we can compute the negative log likelihood of the correct answer as the loss function.


A possible avenue towards having large-scale human-created data is to automatically pick out a large number of generated questions which are representative of or similar to human-created questions.

we train a network to predict whether a question is a generated question or a human-created question.


We hope our dataset provides a valuable testbed to the language modeling community and the machine comprehension community.

the language modeling community can use CLOTH to evaluate their models' abilities in modeling a long context.


From the comparison shown in Figure 2, we see that 1B-LM is indeed good at short-term questions.

when the human only has access to the context of one sentence, 1B-LM is close to human's performance on almost all categories.


When we train the small LM on CLOTH, we largely follow the recommended hyperparameters in the Pytorch LM example 8 .

we employ a 2-layer LSTM with hidden dimension as 1024.


Thus we constrain our dev and test sets to be hard examples.

we randomly divide the hard examples into four subsets, train-hard, dev, test-distractor, and test-fullwiki.


); the difficulty lies in identifying it and meaningfully combining it with a core fact from F to answer the question.

openBookQA questions are challenging as they require multi-hop reasoning with partial context provided by F. unlike existing datasets for reading comprehension (RC), answering questions on the back of a textbook (TQA), 2 as well as question answering over structured knowledge-bases (KBQA), the open book F that comes with openBookQA is not self-contained.


(2017) in writing grammars for our new tasks.

all the task grammars consist of a set of entities (people and objects in the stories) and predicates that take entities as subject or object.


Most traditional SRL methods rely heavily on feature templates that struggle to capture sufficient discriminative information, while neural models are capable of extracting features automatically.

recent works (Zhou and Xu, 2015;He et al., 2017; propose syntax-agnostic models for SRL and achieve favorable results, which seems to be in conflict with the belief that syntactic information is an absolutely necessary prerequisite for high-performance SRL (Gildea and Palmer, 2002).


Word representation Given a sentence and known predicate, we consider predicate-specific word representation, following previous work .

each word embedding representation e i of input sentence is the concatenation of several features, a randomly initialized word embedding e r i , a pretrained word embedding e p i , a randomly initialized lemma embedding e l i , a randomly initialized POS tag embedding e pos i , and a predicate-specific feature e f i , which is a binary flag set 0 or 1 indicating whether the current word is the given predicate.


It is worth noting that our deep encoder is different from the one of Marcheggiani and Titov 2017, which directly applies a softmax transformation over the syntactic representation and predicts the role label for each word.

their syntactic encoder outputs are directly taken as the input of hidden layer.


To integrate the syntactic information into sequential neural networks, we employ a syntactic encoder on top of the BiLSTM encoder.

given a syntactic dependency tree T , for each node n k in T , let C(k) denote the syntactic children set of n k , H(k) denote the syntactic head of n k , and L(k, •) be the dependency relation between node n k and those have a direct arc from or to n k .


At each timestep, it composes an input vector and the hidden states from arbitrarily many child units.

the main difference between Tree-LSTM unit and the standard one is that the memory cell updating and the calculation of gating vectors are depended on multiple child units.


While syntactic grammars (Marcus et al., 1993;Nivre, 2005) induce a rooted tree structure over the sentence by connecting verbal predicates to their arguments, these semantic representations often take the form of the more general labeled graph structure, and aim to capture a wider notion of propositions (e.g, nominalizations, adjectivals, or appositives).

we will focus on the three graph-based semantic representations collected in the Broad-Coverage Semantic Dependency Parsing SemEval shared task (SDP) (Oepen et al., 2015): (1) DELPH-IN Bi- * Work performed while at Bar-Ilan University.


(2017) have noted that different child visiting linearization orders affect the performance of text generation from AMR.

they found that following the order of annotation of a human expert worked best.


To overcome this we artificially increase the softmax probabilities (dashed edges in Figure 3) so that they reflect the DFS path decoded up until that point.

we override the predicted word according to the previous index, and backtrack "up" the corresponding edge.


All of our hyper-parameters were tuned on a held out partition of 1000 sentences in the training set.

we use 3 hidden layers for both of the encoders, and 2 hidden layers for the decoder.


While both models are able to capture the spanlevel correspondence between words and semantics, we can observe that in the relaxed hybrid tree, some words within the span are more directly related to the semantic unit (e.g., "do not" are more related to m 2 ) and some are not.

in their representation, the span level information assigned to the parent semantic unit always contains the span level information assigned to all its child semantic units.


Table 2 shows the feature templates for the example in Figure 2.

we define simple unigram features (concatenation of a semantic unit and a word that directly appears under the unit), pattern features (concatenation of the semantic unit and the child pattern) and transition features (concatenation of the parent and child semantic units).


Table 4 shows the performance of augmenting different dependency features in our DEPHT model with basic features.

we investigate the performance of head word and modifier word features (HM) and also the bag-of-words features (BOW) that can be extracted based on dependencies.


A similar property holds for the other direction of the loop (from B to A and then from A back to B).

we use the Sinkhorn distance (Cuturi, 2013) to capture the distributional similarity between two set of embeddings after transformation, which we found empirically superior to the KL-divergence (Zhang et al., 2017a) and distance to nearest neighbor (Artetxe et al., 2017;Conneau et al., 2017) with regards to the quality of learned transformation as well as the robustness under different training conditions.


During the training of monolingual word embedding for X and Y , we also have the access to the word frequencies, represented by vectors r ∈ N n and c ∈ N m for X and Y , respectively.

r i is the frequency for word (embedding) x i and similarly for c j of y j .


Investigating the data manually, we find an example in the Chinese translation where an entailment relation becomes a contradictory relation, while the entailment is preserved in other languages.

the term upright which was used in English as entailment of standing, was translated into Chinese as sitting upright thus creating a contradiction.


While notable recent approaches have considered building a shared sentence encoder for multiple languages using publicly available parallel corpora (Johnson et al., 2016;España-Bonet et al., 2017), the lack of a large-scale, sentence-level semantic evaluation has limited their adoption by the community.

these works do not cover the scale of languages considered in XNLI, and are limited to high-resource languages.


We propose a simple alignment loss function to align the embedding spaces of two different languages.

we train an English encoder on NLI, and train a target encoder by minimizing the loss: where (x, y) corresponds to the source and target sentence embeddings, (x c , y c ) is a contrastive term (i.e.


During training, mentions from different languages are mixed using inverse-ratio mini-batch mixing strategy.

if two languages have training data sizes proportional to α : β, at any time during training, mini-batches seen from them are in the ratio 1 α : 1 β .


XELMS(joint) performs substantially better than XELMS(mono) on all datasets (Table 3 and 4), proving that using additional supervision from a high resource language like English leads to better linking performance.

xELMS(joint) outperforms the SoTA on all languages in TH-TEST, on Spanish in TAC15-Test, and on 4 of the 7 languages in MCN-TEST.


Formally, we find a Chinese word w's English translation w * as follows: e * = arg maxe∈V e max c∈Vc(w) Score(c, e) where V c (w) is the set of Chinese nodes whose word is w, and w(e) denotes the word of node e. We evaluate our approach on mining translations of bursty Chinese words, based on the evaluation criteria of bilingual lexicon extraction.

we test how many out-of-vocabulary (OOV) words appearing in the Chinese BINet are correctly translated.


to facilitate CSC with data-driven approaches, in this paper, we propose a novel approach that automatically constructs Chinese corpora with labeled spelling errors.

given that Chinese spelling errors mainly result from the misuse of visually and phonologically similar characters (Chang, 1995;Liu et al., 2011;Yu and Li, 2014), we propose OCR-based and ASR-based methods to produce the aforementioned two types of misused characters.


Given a sentence, as the first step, we randomly select 1 ∼ 2 character(s) from it as our target characters to be detected by Tesseract, denoted as C targets .

except for Chinese characters, other characters like punctuations and foreign alphabets are excluded and we also filter those Chinese characters of low frequency 5 based on the statistics of the Chinese Wikipedia Corpus 6 .


Then it is easy to identify whether the incorrectly-recognized characters have similar or same pronunciation with their corresponding characters in the gold sentence.

in terms of Pinyin, two characters have similar pronunciation when they have the same initials and finals but different tones, i.e., da2 and da1.


Figure 4 shows that when the size of training dataset is fixed (=40k), different proportions of P-style and V-style errors achieve different F1 scores, denoting that the proportion of P-style and V-style spelling errors affects the quality of the generated corpus.

it is observed that a 4:6 proportion of D-ocr and Dasr achieves the best performance on three testing datasets when compared with other proportion ratios.


According to previous analyses on the experimental results shown in Figure 4, we choose the 4:6 proportion of P-style and V-style spelling errors to construct the training data in the following experiments.

we build five different sizes of datasets: D-10k 19 , D-20k, D-30k, D-40k and D-50k, which are extracted from  D-ocr and D-asr following the proportion of 4:6.


However, the improvement of the precision is not so obvious as that of the recall.

in Tst 14 and Tst 15 , D-50k does not achieve a higher precision than D-40k.


Following previous studies (Chang, 1995;Huang et al., 2007;Wu et al., 2010;Dong et al., 2016), we adopt confusion sets 21 and a language model to handle the taks for Chinese spelling error correction.

by collecting all incorrect variants for each correct character, we construct a confusion set for all involved correct characters, denoted as Ours.


In addition, to illustrate its effectiveness, we compare it with two publicly available confusion sets (Liu et al., 2009), Con1 and Con2.

con1 consists of Sc (similar cangjie), SSST (same-sound-same-tone) and SSDT (samesound-different-tone), while con2 consists of all sets, Sc, SSST, SSDT, MSST (similar-sound- Tst   same-tone) and MSDT (similar-sound-differenttone).


In this paper, we proposed a hybrid approach to automatic generating Chinese corpus for spelling check with labeled spelling errors.

oCR-and ASR-based methods were used to generate labeled spelling errors by replacing visually and phonologically resembled characters.


The predictor networks are trained using large parallel texts (potentially erroneous learner sentences and their corresponding humancorrected sentences).

the knowledge from the predictor network is transferred to the estimator network that is trained to estimate the quality scorê q given the source sentence S and its corresponding system hypothesis H. a pretrained predictor network takes as input S and H (in place of the target sentence) and predicts probability scores for words in H. the intuition is that hypothesis words that are likely to match the reference sentence will be assigned higher probabilities.


Quality Vectors: While training and testing the estimator, the internal hidden representations from the predictor for every hypothesis word, termed as quality vectors, are used as inputs to the estimator network.

we use the "pre-prediction" quality vectors in (Kim et al., 2017a), which performed the best for our GEC QE task.


Energy Based Model (EBM) Architecture: Our approach is inspired from the graph based parsing approaches employed generally for dependency parsing (McDonald et al., 2005b;Carreras, 2007) and follows a likewise structured prediction paradigm (Taskar et al., 2005).

we use an EBM where we model our joint task as search for a maximal clique with minimum energy.


However, existing local models "regularly make egregious errors" (Manning, 2011), notably on imperative detection 1 .

the applicability of the part-of-speech labeling task is limited by its standard evaluation not reflecting difficult cases which require contextual reasoning to resolve ambiguity.


Our extraction methodology is 5 Nouns and verbs were identified by mapping the fine-grained part-of-speech tag to its coarse-grained category (Petrov et al., 2012): https://github.

com/slavpetrov/universal-pos-tags/blob/ master/en-ptb.map 6 We excluded VBN from the set of verb tags, as it often functions more similarly to non-verbs 7 non-sentence initial tokens 8 Labeled as amod according to a dependency parser 9 Labeled as nn according to a dependency parser Agreement Type # % Unanimous 23,908 71.4% Majority 9,122 27.3% Disagreement 432 1.3% Table 4: Inter-annotator agreement rates.


Training All experiments used the standard splits of the WSJ Penn Treebank and the new Noun-Verb dataset.

wSJ Sections 2-21 were used to train all models; where indicated, this was augmented with the training portion of the Noun-Verb dataset.


When we tease apart the results by part of speech and dependency type, we trace the difference back to the characterlevel model's inability to disambiguate words even when encoded with arbitrary context ( §4).

it struggles with case syncretism, in which noun case-and thus syntactic function-is ambiguous.


However, the effects are more mixed in other languages, even with relatively high OOV rates.

languages with rich morphology like Czech, Russian, and (unvocalised) Arabic see more improvement than languages with moderately rich morphology and high OOV rates like Portuguese or Spanish.


This tool provides high dimensional vectors for audio files that summarizes important statistical descriptors such as loudness, pitch, Mel-spectra, MFCC, etc.

we use the IS13 ComParE 1 extractor which provides 6373 features for each utterance.


For each λ ∈ {a, b}, GRU s λ attempts to model the emotional inertia of speaker P λ which represents the emotional dependency of a speaker with their own previous states.

for each historical utterance u i<t ∈ H λ , an internal memory state h .


Here, users interact with characters whose responses are based on users' emotional state.

we utilize the AVEC 2012's fully continuous sub-challenge (Schuller et al., 2012) that requires predictions of four continuous affective dimensions: arousal, expectancy, power, and valence.


Most of the correctly classified instances focus on the immediate or short history.

63% of the time, at least one of the top-5 attention value belongs to a memory in the short-history range.


In this paper we propose an approach towards this goal: We address the task of visual SRL (vSRL) and learn frame-semantic representations of images.

we present a model that learns to ground the semantic roles of a semantic frame in image regions, which may be crucial for, e.g., human-robot interaction or surveillance (e.g., Who/Where is the robber?).


1), where we discard all candidates of role-filler pairings with a score less than zero.

given an image i, we formulate the role prediction problem as a mapping L: the predicted role (and the frame it is associated with) which an image region r ∈ R i of i fills is that e ∈ E to which r is most similar in the visual-frame-semantic space.


Some verbs and the frame types which they evoke occur very frequently in the set of annotations (e.g., BEING LOCATED) and therefore allow the induction of a finer-grained frame inventory.

we transform each frame which is evoked by an individual verb (e.g., stand or sit) for at least 100 images (as obtained from the captions) in the Flickr30k Entities training split to a finer-grained frame type by concatenating it with the verb (e.g., BEING LOCATED-sit ).


To enable collaboration and communication between humans and agents, this paper investigates learning to acquire commonsense evidence for action justification.

we have developed an approach based on the generative Conditional Variational Autoencoder (CVAE) that models object relations/attributes of the world as latent variables and jointly learns a performer that predicts actions and an explainer that gathers commonsense evidence to justify the action.


An increasing amount of work on the Visual Question Answering (VQA) task (Antol et al., 2015;Lu et al., 2016) has also looked into more interpretable approaches, for example, by utilizing attention-based models (Fukui et al., 2016) or reasoning based on explicit evidence (Wang et al., 2017).

for action understanding, recent work explicitly models commonsense knowledge including causal relations (Gao et al., 2016;Forbes and Choi, 2017;Zellers and Choi, 2017;Gao et al., 2018) related to concrete actions, which can facilitate action explanation.


Based on all these definitions, our goal is to jointly select evidence z and predict target action a ∈ A.


Following the method in , our semi-supervised learning loss function is defined as: where L SV is defined in section 5.2 and L CV AE is detailed in section 5.1.

the data sample with evidence label is fed to L SV , otherwise is fed to L CV AE .


The ability to infer and model personality has applications in storytelling agents, dialogue systems, and psychometric analysis.

personality-infused agents can help "chit-chat" bots avoid repetitive and uninteresting utterances (Walker et al., 1997;Mairesse and Walker, 2007;Li et al., 2016;Zhang et al., 2018).


We again use the skip thought vectors to represent the descriptions.

we want to maximize the similarity of representations obtained from dialogue snippets with their corresponding description, and minimize their similarity with negative examples.


We were also able to leverage prior knowledge in the form of textual descriptions of the trope.

using these descriptions to initialize our Knowledge-Store memory helped improved performance.


Our approach to machine translation builds on insights from these prior efforts.

we focus on end-to-end learning for statistical machine translation due to the recent success of Neural Networks in Natural Language Processing (Goodfellow et al., 2016).


to take as input not only natural language instructions, but also the corresponding behavioral navigation graph m of the environment where navigation should take place.

at each step, the graph m operates as a knowledge base that the model can access to obtain information about path connectivity, facilitating the grounding of navigation commands.


We pre-processed the inputs to the various models that are considered in our experiment.

we lowercased, tokenized, spell-checked and lemmatized the input instructions in text-form using WordNet (Miller, 1995).


In general, we used 12.5% of the training set as validation for choosing models' hyperparameters.

we used dropout after the encoder and the fully-connected layers of the proposed model to reduce overfitting.


Lastly, it is worth noting that our proposed model (last row of Table 3) outperforms all other models in previously seen environments.

we obtain over 4% increase in EM and GM between our model and the next best two models.


We chose this kind of data in order to prevent possible errors produced by the automatic annotation of sentences.

we considered the newspaper section of the Italian Universal Dependency Treebank (UDT) (Simi et al., 2014) and the automatically converted Wall Street Journal section of the Penn Treebank (McDonald et al., 2013).


As it can be seen, the model is very accurate and achieves a very high correlation (>0.56 with p <0.001) with an average error difference (avg mean abs err) below 1.

the model obtained higher performance in predicting the ranking of features extracted from sentences at agreement 14.


While earlier research (Bergsma and Wang, 2007;Barr et al., 2008) suggested that many queries are trivial in structure,   (henceforth PRS16) demonstrated that this is often not the case.

they demonstrated that queries related to questions that are answered in Community Question Answering (CQA) sites (social QA forums such as Yahoo Answers), follow a complex dependency grammar.


We next describe our modification of the KG16 parser.

we change the transition logic so that it can directly account for the query grammar defined in PRS16.


The segmentation-aware parsers section of the table shows that further extending the arc-eager KG16 parser to explicitly account for segmentation results in substantial segmentation improvements.

the overall F1-score of P B -our segmentation-aware parser that does not use information from any auxiliary segmentation models -is as high as 77.4.


of a string with respect to a given distribution.

given a PFA P and a string w, one might ask the probability of w appearing as a prefix, suffix, or infix in the distribution modeled by P-in other words, the sum of the probabilities of all strings in the form of wx, xw, or xwy with respect to P, for some strings x and y.


We then construct a new table, β where β k i,j = M P (α k i,j ).

α holds the regular expressions generated during state elimination while β holds the corresponding matrices.


We cannot simply append (or prepend) the desired character to a precomputed regular expression because the resulting expression may not be unambiguous or may represent the a different language.

to tackle this problem, we first define the language F(w) to be the set of strings that end in the first occurrence of w. F(w) = {x | w appears only as a suffix of x}.


As seen in the example, a syntax tree has labeled nodes.

the label of each node is a "syntax token", such as S, NP, VP, etc., representing the grammatical property of the word sequences covered by tree branches underneath the node.


, n} be an (unordered) set containing precisely all syntax paths for the words in s. Then the syntax tree of s can be uniquely recovered by R. In the lemma, we note that R is an unordered set.

regardless of the ordering of the paths in R, one can always recover the syntax tree from R. Let r(w) be the syntax path of a word w in the sentence s of interest.


That is, regardless of the ordering of the paths in R, one can always recover the syntax tree from R. Let r(w) be the syntax path of a word w in the sentence s of interest.

r(w) can be written as the sequence (t , where L is the number of nodes in the path r, and each t i is a syntax token.


Despite the previous successes in solving the AA problem discussed in a previous section, we argue that the syntactic parse information in an author's writing can characterize in part the "writing style" of the author.

even when writing the same content, two authors may prefer using different syntax structure in constructing their sentences.


But they show a difference in terms of syntax information contained.

the former is constructed by deep parse trees, but the later has a succinct parse tree structure.


We conduct experiments on both the Blogs10 and Blogs50 datasets with and without the position embedding.

by "without position", we mean that the element-wise multiplication with the p j is removed from equation (1) in Section 3.


Here, we propose a reweighting method for responses of a query x.


This validates that the properties about similarity frequency and sentence length play important roles in generating better responses.

relevance Acceptance Seq2Seq 1.96±3.8e-5 1.31±5.3e-3 0.42±4.7e-4 Seq2Seq-rS 1.97±8.1e-5 1.30±2.1e-3 0.42±9.9e-4 Seq2Seq-MMI 1.94±7.2e-5 1.19±4.0e-3 0.41±1.9e-4 Seq2Seq-DD 1.86±2.8e-3 1.40±1.5e-2 0.49±2.4e-3 Ours-rWE 1.95±1.9e-4 1.30±5.1e-3 0.42±4.2e-4 Ours-rWF 1.97±1.5e-4 1.47±2.1e-3 0.51±6.3e-4 Ours-rWEF 1.96±8.3e-5 1.59±1.9e-2 0.55±4.4e-3 the average percentage of the generated responses that are assigned to relevance rating 2 (relevant, including the generic responses) and 3 (relevant as well as interesting) are presented in Table 4.


• StateNet: It doesn't have shared parameters among different slots.

three models for three slots are trained separately using RMSProp optimizer, learning rate set to 0.0005.


A key advantage of our representation is that it has a structure similar to standard constituency parses, allowing us to easily adapt algorithms developed for phrase structure parsing for inference.

we use linear-time Recurrent Neural Network Grammars (RNNG) (Dyer et al., 2016) and show that the inductive bias provided by this model significantly improves the accuracy compared to strong sequence-to-sequence (seq2seq) models based on CNNs, LSTMs and Transformers.


We show that the representation is learnable by standard algorithms.

we show that the RNNG parsing model outperforms seq2seq baselines.


The discussion of gender representation or even the existence of a glass ceiling is rather more complex for NLP due to its fundamental interdisciplinarity especially across the fields of Linguistics, Computer Science, and Statistics.

much mainstream research in NLP follows trends that are heavily situated in one of the main subdisciplines.


In Table 1 we observe a similar trend for in-gender mentorship.

female researchers who have female mentors are much more likely to become mentors themselves.


We first propose one simple method to get around the assumption of complete annotation -train separate CRFs for the label set of each dataset.

to share statistical strengths on the input tokens, we share the BiLSTM feature encoder across the datasets but use separate CRF layers for each of the datasets.


One interesting problem that our models do not account for is the existence of overlapping and non-continuous entity spans.

when annotating using disjoint label sets, a token could belong to multiple entity spans from different label sets.


We show how to use AT for the tasks of entity recognition and relation extraction.

we demonstrate that applying AT to a general purpose baseline model for jointly extracting entities and relations, allows improving the state-of-the-art effectiveness on several datasets in different contexts (i.e., news, biomedical, and real estate data) and for different languages (English and Dutch).


Neural network methods have been exploited to overcome this feature design issue and usually involve RNNs and CNNs (Miwa and Bansal, 2016;Zheng et al., 2017).

miwa and Bansal (2016) as well as Li et al.


We exploit the idea of AT (Goodfellow et al., 2015) as a regularization method to make our model robust to input perturbations.

we generate examples which are variations of the original ones by adding some noise at the level of the concatenated word representation (Miyato et al., 2017).


We evaluate our models on four datasets, using the code as available from our github codebase.

1 we follow the 5-fold crossvalidation defined by Miwa and Bansal (2016) for the ACE04 (Doddington et al., 2004) dataset.


2, the performance of the models using AT is closer to maximum even from the early training epochs.

for ACE04, there is an improvement in both tasks as well as in the overall F 1 performance (0.4%).


We are motivated by problems in biomedical NLP (Zweigenbaum et al., 2007;Demner-Fushman et al., 2016).

scientific abstracts in this domain are typically associated with multiple Medical Subject Heading (MeSH) terms.


Both of these are initialized to zero vectors and recursively updated during traversal, i.e., as nodes are selected for expansion (and hence added to the predicted tag set).

more specifically, the context vector that informs the decision to expand node v in the label hierarchy from its parent node n is a weighted sum of the encoder hidden states h, where weights reflect induced attention over inputs, conditioned on n. : where and a is a simple multi-layer perceptron (mLP), with node-specific parameters θ n .


At train time we use teacher forcing (Williams and Zipser, 1989) during decoding.

we revert the model back to the correct (training) tree subsequence when it goes off-course, and continue decoding from there.


They use linear models for both tasks, which operate over TF-IDF representations of abstracts.

they train a regressor to predict k, the number of MeSH terms to be applied to an abstract.


Here, we extend the model by incorporating an auto-encoder loss taking hand-crafted features as in/output, thereby forcing the model to preserve crucial information stored in such features and allowing us to evaluate the impacts of each feature on model performance.

our model, referred to as Neural-CRF+AE, consists of four major components: (1) a character-level CNN (char-CNN); (2) a word-level bi-directional LSTM (Bi-LSTM); (3) a conditional random field (CRF); and (4) an auto-encoder auxiliary loss.


This paper presents a simple framework for characterizing morphological complexity and how it encodes syntactic information.

we propose a new measure of morphosyntactic complexity in terms of governordependent preferential attachment that explains parsing performance.


values for POS, number, case, tense, mood...)) for a given language.

correspondingly, let c be the set of contexts defined over elements of V. lemmas appear in the context of other lemmas, forms in the context of forms, and attributes in the context of attributes.


The advent of Neural Machine Translation (NMT) (Sutskever et al., 2014;Bahdanau et al., 2014) has led to remarkable improvements in machine translation quality (Bentivogli et al., 2016) but has also produced models that are much less interpretable.

the role played by linguistic features in the process of understanding the source text and rendering it in the target language remains hard to gauge.


We then hide the affix in the input form and learn to inflect.

we map the word form walked into walk$$ and then learn a mapping walk$$+PAST → walked.


In this work, we introduce a disagreement regularization to explicitly encourage the diversity among multiple attention heads.

we propose three types of disagreement regularization, which respectively encourage the subspace, the attended positions, and the output representation associated with each attention head to be different from other heads.


The disagreement regularization serves as an auxiliary objective to guide the training of the related attention component.

we propose three types of disagreement regularization, which are applied to the three key components that refer to the calculation of feature vector using multi-head attention.


To further guarantee the diversity, we enlarge the distances among multiple attention heads with disagreement regularization (Section 3.1).

we propose three types of disagreement regularization to encourage each head vector O i to be different from other heads (Section 3.2).


This disagreement is designed to maximize the cosine distance between the projected values.

we first calculate the cosine similarity cos(•) between the vector pair V i and V j in different value subspaces, through the dot product of the normalized vectors 1 , which measures the cosine of the angle between V i and V j .


Finally, we validate the proposed disagreement regularization on both WMT17 Chinese-to-English and WMT14 English-to-German translation tasks.

we adopt the Output disagreement regularization, which is applied to all three attention networks.


3 Experimental Setup In this work, we consider only uncertainty-based acquisition.

we consider least confidence (LC) for classification and maximum length-normalized log probability (MNLP) for sequence labeling tasks (Shen et al., 2018).


In our work we utilize this approach to achieve vocabulary sparsification.

we introduce multiplicative probabilistic weights z ∈ R V for words in the vocabulary (here V is the size of the vocabulary).


The goal of marginal estimation is to determine the likelihood of a short phrase where the preceding context is not known; we refer to this likelihood as a marginal probability.

the marginal probability of a query refers to how likely a language model will generate a query regardless of context.


This implies that z ψ is trained to maximize the likelihood of different subsequent texts of different lengths, and thus is an approximately good starting point for any sequence.

a new state is computed during the training as follows: where r ∼ Bern(ρ) and ρ is a hyper-parameter for the probability of resetting a state.


Smaller tied+L models perform well compared to larger tied models.

the tied+L model with 600/400 units has perplexity of 76.0, compared to 76.1 of the tied 600/600 model, with 55% the number of parametres.


The word-level abstraction summarizes information from each previous sentence j into a vector s j as: where h denotes a hidden state of the NMT network.

h t is the last hidden state of the word to be encoded, or decoded at time step t, and h j i is the last hidden state of the i-th word of the j-th sentence of the context.


The experimental results demonstrate that the three strategies can significantly outperform the baseline multilingual models and they can achieve comparable or even better performance than the individually trained translation models.

our contributions in this paper are two-fold: • The proposed three strategies can take advantage of unique features of each target language while sharing the network parameters as many as possible.


We can observe from the table that all our proposed strategies (last part in Table 1) improve the translation performance compared to the baseline (O2M).

the combined use of three strategies performs best and it can achieve the improvements up to 1.96 BLEU points (45.51 vs. 43.55 on Zh→En MT04).


In line with previous work on NMT on long sentences (Bahdanau et al., 2015;Li et al., 2017), we see a significant deterioration in BLEU for longer  sentences for all systems.

although the parse2seq model outperformed the seq2seq model overall, it does worse than seq2seq for sentences containing more than 30 words.


In our assumption, the temperature parameter is learned based on the information of the decoding at the current time step as well as the attention in the previous time steps, referring to the information about what has been translated and what is going to be translated.

it 2 What should be mentioned is that though the "Transformer" model is recently regarded as the best, the model architecture is not the focus of our study.


To examine whether the 2DLSTM reduces the need of attention, in the second set of experiments, we equip our model with a weighted sum of 2DLSTM states, t i , over j positions to dynamically select the most relevant information.

: In these equations, γ j,i is the normalized weight over source positions, s j,i is the 2DLSTM states and W and v are weight matrices.


We treat the matched TM translation as an additional signal and try to encode it with a new encoder to guide the NMT decoder to translate the current sentence.

we first find the sentence that is most similar to the current source sentence from TM by calculating their semantic similarity based on sentence embeddings.


The conditional probability of the next word y t is calculated as follows: Please notice that we only incorporate the gated TM into the hidden state of the decoder, rather than the prediction of the next word.

our goal is to correctly translate the source sentence with reference to the translation of the TM match tm t. tm t only plays a supporting role in translation.


At each position, we can take one of the following editing operations: (i) KEEP to keep the word and go to the next word, (ii) DELETE to delete the word and go to the next word, (iii) IN-SERT(WORD) to insert a new WORD and stay in that position, or (iv) STOP to terminate the process.

the size of the operation set equals the size of the target vocabulary plus three, where we add the symbols KEEP, DELETE, and STOP as new tokens.


In all settings, our MT+AG+LM models outperforms the MT+AG and monolingual/multi-source SEQ2SEQ models.

our model outperform MT+AG in 500K+12K training condition by almost 1 BLEU score on test2017.


3 We first review existing methods to counter the length problem and then propose new ones to address their limitations.

we propose to predict the target length from the source sentence, in order to choose a hypothesis with proper length.


While our experiments show a promising direction towards obtaining bilingual embeddings for CM tasks, there are several interesting ideas that are worth exploring.

the linguistic model used for generating artificial CM data only addresses the syntactic constraints of CM, but not other kinds of constraints such as lexical choice which in a particular CM context might be overly skewed towards one language (like the English words 'school' and 'vote' are more common than their Hindi translations in English-Hindi CM ), and semantic/pragmatic constraints that make the choice of a particular language more common in some contexts (e.g., Hindi used more commonly for negative sentiment during English-Hindi CM (Rudra et al., 2016)).


In the future, we plan to make a more thorough analysis of reasons for the high variance in NER performance.

we will study why it is possible, as with Tagalog, to have high Named Entity Identification results but lose points in NER.


In this work, we explore mechanisms that can significantly improve upon such a baseline when applied to codeswitched text.

we develop two such mechanisms: • We alter the structure of an RNN unit to include separate components that focus on each • We propose using same-source pretrainingi.e., pretraining the model using data sampled from a generative model which is itself trained on the given training data -before training the model on the same training data (see Section 3).


Since there are K existing intents and L emerging intents, the similarities between existing and emerging intents form a matrix Q∈R L×K .

the similarity between an emerging intent z l ∈Z and an existing intent y k ∈Y is computed as: where d (e z l , e y k ) = (e z l − e y k ) T Σ −1 (e z l − e y k ) .


It outputs a new sequence of contextualized sentence encoding vectors, which are enriched with the contextual information from surrounding sentences.

the sequence of individual sentence encoding vectors is input into a bi-LSTM layer, which produces a sequence of hidden state vectors h 1:n (h ∈ R d hd ) with each corresponding to a sentence.


From the results, we observe that the capsule networks achieve best results on 4 out of 6 benchmarks, which verifies the effectiveness of the capsule networks.

our model substantially and consistently outperforms    To analyze the effect of varying different components of our capsule architecture for text classification, we also report the ablation test of the capsule-B model in terms of using different setups of the capsule network.


From the results, we can observe that the capsule networks have substantial and significant improvement in terms of all four evaluation metrics over the compared baseline methods on the test sets in both Reuters-Multi-label and Reuters-Full datasets.

larger improvement   is achieved on Reuters-Multi-label dataset which only contains the multi-label documents in the test set.


These three components can be updated simultaneously via a joint learning process, which is introduced in Section 2.3.

for the classifier, our TMN framework allows the combination of multiple options, e.g., CNN and RNN, which can be determined by the specific application scenario.


Each topic k is represented by a word distribution φ k over the vocabulary.

the generation story for x is: • For the n-th word in x: is a neural perceptron that linearly transforms inputs, activated by a non-linear transformation.


Then, in target memory, via weighting target memory matrix T with ξ, we obtain the output representation R of the topic memory mechanism: The concatenation of R and U (embedded x Seq ) further serves as the features for classification.

similar to the memory networks in prior research (Sukhbaatar et al., 2015;Chen et al., 2017), our model can be extended to handle multiple computation layers (hops).


6 Following previous settings (Yan et al., 2013;Li et al., 2016a), hashtags, i.e., user-annotated topic labels in each tweet such as "#Trump" and "#Su-perBowl", serve as our ground-truth class labels.

we construct the dataset with the following steps.


We also consider other SVM-based baselines: SVM+LDA, SVM+BTM, SVM+NTM, whose features are topic distributions for instances learned by LDA (Blei et al., 2003), BTM (Yan et al., 2013), and NTM (Miao et al., 2017), respectively.

bTM is one of the state-ofthe-art topic models for short texts.


By exploring topic representations in memory mechanisms, our TMN model, inferring topic models either separately or jointly with classification, significantly outperform the best comparison models on each of the four datasets.

when compared with CNN+TEWE and CNN+NTM, both concatenating topics as part of the features, the results yielded by TMN are better.


Taking advantage of this prior knowledge on labels is vital for zero-shot prediction.

using the EMR coding use-case, we make the following contributions: 1.


The groups are only used for evaluation.

during training, systems are optimized over all labels simultaneously.


Finally, we generate label vectors using the ICD-9 hierarchy.

let Y ∈ R N ×L be the document label matrix where N is the total number of documents.


To overcome this problem and improve the quality of generated responses, we propose a novel model, named Variational Autoregressive Decoder (VAD) to iteratively incorporate a series of latent variables into the autoregressive decoder.

a distinct latent variable sampled from CVAE is associated with each time step of the generation, and it is used to condition the next state of the autoregressive decoder (e.g., the hidden state of a RNN).


The major goal of the loss functions is to support the model in generating the simplified word "winner" while deterring the model from generating the word "recipient".

for an applicable simplification rule, our new loss function maximizes the probability of generating the simplified form (word "winner") and meanwhile minimizes the probability of generating the original form (word "recipient").


It is the largest Wikipedia corpus, constructed by merging previously created simplification corpora.

the training dataset contains 296,402 normalsimple sentence pairs gathered from (Zhu et al., 2010;Woodsend and Lapata, 2011;Kauchak, 2013).


SARI, which stands for "System output Against References and against the normal sentence", computes the arithmetic mean of Ngrams (N includes 1,2,3 and 4) F1-score of three rewrite operations: addition, deletion, and keeping.

it rewards addition operations where a word in the generated simplified sentence does not appear in the normal sentence but is mentioned in the reference sentences.


By analyzing the outputs, the increased number of layers or heads results in better capability to simplify the words.

models with the greater number of layers or heads tend to remove the normal words and add simplified words.


More importantly for us, however, they can also be used to guide generation.

since each MAP segmentation implies a sequence of hidden states z, we may run a template extraction step, where we collect the most common "templates" (i.e., sequences of hidden states) seen in the training data.


With our templates z (i) in hand, we can then restrict the model to using (one of) them during generation.

given a new input x, we may generate by computinĝ which gives us a generationŷ (i) for each extracted template z (i) .


To demonstrate empirically that the learned states indeed align with field types, we calculate the average purity of the discrete states learned for both datasets in Table 5.

for each discrete state for which the majority of its generated words appear in some r j , the purity of a state's record type alignment is calculated as the percentage of the state's words that come from the most frequent record type the state represents.


More importantly, encouraged by the success of training with multiple human references, we further propose a framework to generate many more pseudo-references automatically.

we design a neural multiple-sequence alignment algo-rithm to compress all existing human references into a lattice by merging similar words across different references (see examples in Fig.


To this end, in this paper, we extend existing KGE models TransE, TransH and Dist-Mult, to learn knowledge representations by leveraging the information from the HRS.

our approach is capable to extend other KGE models.


In the proposed models, for each knowledge triple (h, r, t), the embedding of r is the sum of three embedding vectors, which correspond to the three layers of the HRS respectively and therefore, the information from the HRS is leveraged.

instead of using additional information like text or paths, our model simply use the knowledge triples in KGs and the rich information from the HRS.


Note that for each corrupted triple (h , r, t ), the sub-relation is determined by t − h , i.e., the k-means model is adopted to assign t − h to a specific sub-relation of r. We rank all the candidate entities according to the scores.

positive candidates are supposed to precede negative ones.


We propose neural encoders and decoders to replace initial layers of any embeddingbased relational model; we apply them to Dist-Mult  and ConvE (Dettmers et al., 2018) here.

instead of learning a distinct vector for each entity and using enumeration to predict links, MKBE includes the following extensions: (1) introduce additional neural encoders to embed multimodal evidence types that the relational model uses to predict links, and (2) introduce neural decoders that use an entity's embedding to generate its multimodal attributes (like image and text).


(2018) that consists of binary cross-entropy loss without negative sampling for both ConvE and Dis-Mult scoring.

for a given subjectrelation pair (s, r), we use a binary label vector t s,r over all entities, indicating whether s, r, o is observed during training.


Numerical and Categorical data To recover the missing numerical and categorical data such as dates, gender, and occupation, we use a simple feed-forward network on the entity embedding to predict the missing attributes.

we are asking the model, if the actual birth date of an entity is not in the KB, what will be the most likely date, given the rest of the relational information.


Images Similar to text recovery, to find the missing images we use conditional GAN structure.

we combine the BE-GAN (Berthelot et al., 2017) structure with pix2pix-GAN (Isola et al., 2017) model to generate high-quality images, conditioning the generator on the entity embeddings in the knowledge base representation.


There is a rich literature on modeling knowledge bases using low-dimensional representations, differing in the operator used to score the triples.

they use matrix and tensor multiplication (Nickel et al., 2011;Socher et al., 2013), Euclidean distance (Bordes et al., 2013;Wang et al., 2014;Lin et al., 2015), circular correlation (Nickel et al., 2016), or the Hermitian dot product (Trouillon et al., 2016) as scoring function.


While large KBs are a problem for all embedding-based link prediction techniques, MKBE is not significantly worse than existing ones because we treat multimodal information as additional triples.

although multimodal encoders/decoders are more expensive to train than existing relational models, the cost is still additive as we are effectively increasing the size of the training dataset.


Our unified model is a multi-task setup that shares parameters across low-level tasks, making predictions by leveraging context across the document through coreference links.

we extend prior work for learning span representations and coreference resolution (Lee et al., 2017;.


Phrases are heuristically normalized (described in Section 6) using entities and coreference links.

we link all entities that belong to the same coreference cluster to replace generic terms with any other nongeneric term in the cluster.


Our policy-based agent acts as the questioner that can ask 20 questions to figure out what exactly o tgt is.

an internal state vector s is maintained by our agent, which describes the confidence about o tgt .


7 We use a user simulator to train our questioner agent and test the agent with the simulated answerer and real users.

our experiments answer three questions: (1) Is our method more robust in real-world Q20 games, compared to the methods based on relevance table?


To further investigate the performance of our RL method in the real-world Q20 game where noisy answers are common, we also conduct an human evaluation experiment.

we let real users to play the game with EntropyModel and RL uniform for 1,000 times respectively.


It shows that our RL method is more robust to noisy answers than EntropyModel.

the robustness of our RL method to the noise is shown in the following two aspects.


More recent work formulates multi-hop reasoning as a sequential decision problem, and leverages reinforcement learning (RL) to perform effective path search Das et al., 2018;Shen et al., 2018;.

mINERVA (Das et al., 2018) uses the RE-INFORCE algorithm (Williams, 1992) to train an end-to-end model for multi-hop KG query answering: given a query relation and a source entity, the trained agent searches over the KG starting from the source and arrives at the candidate answers without access to any pre-computed paths.


The search can be formulated as a Markov Decision Process (MDP) (Sutton and Barto, 1998): starting from e s , the agent sequentially selects an outgoing edge l and traverses to a new entity until it arrives at a target.

the MDP consists of the following components (Das et al., 2018).


The search policy is parameterized using state information and global context, plus the search history (Das et al., 2018).

every entity and relation in G is assigned a dense vector embedding e ∈ d and r ∈ d .


Multi-hop reasoning focus on learning symbolic inference rules from relational paths in the KG and has been formulated as sequential decision problems in recent works Das et al., 2018;Shen et al., 2018;.

deepPath  first adopted REINFORCE to search for generic representative paths between pairs of entities.


For some path based approaches, computation cost is a bottleneck.

neuralLP and nTP-λ failed to scale to the larger datasets and their results are omitted from the table, as Das et al.


We are interested in studying the impact of each proposed enhancement on the training convergence rate.

we expect reward shaping to accelerate the convergence of RL (to a better performance level) as it propagates prior knowledge about the underlying KG to the agent.


In general, the proposed approach is able to converge to a higher accuracy level much faster than either of the ablated models and the performance gap often persists until the end of training (on UMLS, Kinship, and FB15k-237).

on FB15k-237, our approach still shows improvement even after the two ablated models start to overfit, with −AD beginning to overfit sooner.


For each KG, we classify its set of relations into two categories based on the answer set cardinality.

we define the metric ξ r as the average answer set cardinality of all queries with topic relation r. We count r as a "to-many" relation if ξ r > 1.5, which indicates that most queries in relation r has more than 1 correct answer; we count r as a "to-one" relation otherwise, meaning most queries of this relation have only 1 correct answer.


With our hyperparameters, we follow Kann and Schütze (2016a).

our encoder and decoder GRUs have 100-dimensional hidden states.


Analogously, the T-orders predicted by stochastic and categorical Harmonic Grammar coincide.

these stochastic constraint-based frameworks do not tamper with the typological structure induced by the corresponding categorical frameworks.


Definition 2 then requires that grammar to also assign probability 1 to the consequent mapping ( x, y).

the grammar construed categorically succeeds on the consequent mapping, as required by the original definition 1 of categorical T-orders.


Analogously, the T-orders predicted by stochastic HG coincide with those predicted by categorical HG, as shown in section 5.

these stochastic frameworks do not tamper with the typological structure induced by the original categorical frameworks, at least when that structure is measured in terms of T-orders.


The ME T-orders instead obey a rather different underlying convex geometry and turn out to be much sparser.

mE yields a much richer probabilistic extension of categorical HG than stochastic HG does.


Suppose that for every categorical grammar G, the family P contains a probability mass function p which assigns all the probability mass to that grammar G. By (1), the corresponding stochastic grammar G p assigns probability 1 to the mappings enforced by G, as stated in (7).

the stochastic grammar G p "coincides" with the categorical grammar G and the stochastic typology T P thus "contains" or "extends" the original categorical typology T. In this special case, we obviously expect the stochastic , as desired.


Suppose that the UR /cost us/ comes with the three candidate SRs [cost.us OT → (/cost.me/, [cos.me]) holds relative to the OT typology generated by constraints C 1 , C 2 , C 3 in the sense of definition 1: every ranking of the three constraints which succeeds on the antecedent mapping (/cost.us/, [cos.us]) also succeeds on the consequent mapping (/cost.me/, [cos.me]).

t/d deletion before a vowel entails deletion before a consonant.


, n are all bounded between −∆ and +∆ with probability at least 1/2 and since the ranking values are spaced apart by more than 2∆, the constraint ranking θ+ corresponding to the stochastic ranking vector θ + coincides with the original ranking with probability at least 1/2.

the probability mass function p D θ corresponding to this ranking vector θ according to (8) assigns more than half of the probability mass to the OT grammar corresponding to the ranking .


W i denotes the i-th column of the weight matrix W .

when we want to calculate the contribution of a subset of characters, where S is the set of corresponding character position indexes and S ⊆ {1, ..., T }, we should decompose the output of the filter z t into three parts: the relevant contribution β t originating from the selected subset of characters with indexes S, the irrelevant contribution γ t originating from the remaining characters in the sequence, and a bias which is deemed neutral (Murdoch et al., 2018).


For the character-level BiLSTM architecture, we follow the variant used in .

we simply run a BiLSTM over all the characters and concatenate the final forward and backward hidden state.