The complexity of this step is O(L L is the sequence length and B is the batch size.

the complexity of LSTM is O(L because of the hidden-to-hidden multiplications (e.g.


As expected, the performance of the stacked model declines when increasing the stack depth.

the performance of CSRAN improves by adding additional layers.


As a result, residual strategies have often been employed Srivastava et al., 2015;Huang et al., 2017).

to the best of our knowledge, this work presents a new way of residual connections, leveraging on the fact that pairwise formulation of the text matching task.


2 In this way, the model initially learns to use the latent code but is then regularized towards the prior as training progresses.

this trick is not sufficient to avert KL collapse in all scenarios, particularly 2 Reweighting the KL term is also used in methods like β-VAE (Higgins et al., 2017) and InfoVAE (Zhao et al., 2017b).


6 Results Experimental results 7 are shown in Table 4.

with NVRNN, the NVDM fully relies on the power of latent code to predict the word distribution, so we never observe a KL collapse, yet vMF still achieves better performance than Gaussian.


Brittleness of Learning κ Throughout this work, we have treated κ as a fixed parameter.

we can treat κ in the same way as σ in the Gaussian case and learn it on a per-instance basis.


The most widely used method is to employ an encoder-decoder architecture with recurrent neural networks (RNN) to predict the original input sentence or surrounding sentences given an input sentence Ba et al., 2016;Hill et al., 2016;Gan et al., 2017).

the RNN becomes time consuming when the sequence is long.


The max pooling takes the maximum value over the sequence, which tries to capture the most salient property while filtering out less informative local values.

the mean pooling does not make sharp choices on which part of the sequence is more important than others, and so it captures general information while not focusing too much on specific features.


Surprisingly, these two methods often achieve similar or better performance than PV-DBOW and PV-DM, which may be because of the high-quality pre-trained word embeddings.

doc2VecC achieves much better testing accuracy than these previous methods on two datasets (20NEWS, and RECIPE_L).


The former primarily generate general purpose and domain independent embeddings of word sequences (Socher et al., 2011;Kiros et al., 2015;Arora et al., 2017); many unsupervised training research efforts have focused on either training an auto-encoder to learn the latent structure of a sentence (Socher et al., 2013), a paragraph, or document (Li et al., 2015); or generalizing Word2Vec models to predict words in a paragraph (Le and Mikolov, 2014;Chen, 2017) or in neighboring sentences (Kiros et al., 2015).

some important information could be lost in the resulting document representation without considering the word order.


This "domino-toppling" technique could have in principle a quadratic complexity in the number  of crosslingual clusters.

we have verified that in practice it converges very fast, and in our evaluation dataset only 1% of the crosslingual updates result in topples.


Multi-task learning in text classification leverages implicit correlations among related tasks to extract common features and yield performance gains.

a large body of previous work treats labels of each task as independent and meaningless one-hot vectors, which cause a loss of potential label information.


we apply the above equations to implement L I with hidden size m. it is inappropriate to apply a BiLSTM for L L , as most labels contain only one or two words.


Zero Update achieves competitive performances in Case 1 (90.9 for IMDB) and Case 2 (86.7 for Kitchen), as tasks from these two cases all belong to sentiment datasets of different cardinalities or domains that contain rich semantic correlations with each other.

the result for IMDB in Case 3 is only 74.2, as sentiment shares less relevance with topic and question type, thus leading to poor transferring performances.


With the development of Deep Learning, neural methods are applied to this task and achieved improvements (Zhang and Zhou, 2006;Nam et al., 2013;Benites and Sapozhnikova, 2015).

these methods cannot model the internal correlations among labels.


We can produce low-dimensional variables using, for example, text classifiers, and then run our causal analysis.

this straightforward integration belies several potential issues.


There is a conceptually related line of work in the NLP community on inferring causal relationships expressed in text (Girju, 2003;Kaplan and Berry-Rogghe, 1991).


Currently, state-of-the-art approaches to disfluency detection depend heavily on hand-crafted pattern match features, specifically designed to find such "rough copies" (Zayats et al., 2016;Jamshid Lou and Johnson, 2017).

to many other sequence tagging tasks (Plank et al., 2016;Yu et al., 2017), "vanilla" convolutional neural networks (CNNs) and long shortterm memory (LSTM) models operating only on words or characters are surprisingly poor at disfluency detection (Zayats et al., 2016).


For the ACNN, we considered a range of possible binary functions f (u, v) to compare the input vector u = x t with the input vector v = x t in the auto-correlational layer.

in initial experiments we found that the Hadamard or elementwise product (i.e.


In many NLP applications including language modeling, the input vector is a dense word embedding which is shared across all contexts for a given word in a dataset.

the context vector is highly contextualized by the current sequence.


With grouped linear and pyramidal transformations, PRUs learn rich representations at very high dimensional space while learning fewer parameters.

lSTMs overfit to the training data at such high dimensions and learn 1.4× to 1.8× more parameters than PRUs.


(2015) empirically concludes that syntax tree-based sentence modeling are effective for tasks requiring relative long-term context features.

some works propose to abandon the syntax tree but to adopt the latent tree for sentence modeling (Choi et al., 2018;Maillard et al., 2017;Williams et al., 2018).


Despiting the linear structured left-branching and rightbranching tree encoders, we find that, tree-based encoders generally perform better than Bi-LSTMs on tasks of sentence relation and sentence generation, which may require relatively more long term context features for obtaining better performances.

the improvements of tree encoders on NLI and Para are relatively small, which may be caused by that sentences of the two tasks are shorter than others, and the tree encoder does not get enough advantages to capture long-term context in short sentences.


The latent tree is really competitive on some tasks, as its structure is directly tuned by the corresponding tasks.

it only beats the binary balanced tree by very small margins on NLI and ARP.


To generate labelspecific topics, several supervised topic models which adopt likelihood-driven objective functions have been proposed.

it is hard for them to get a precise estimation on both topic discovery and supervised learning.


This is because the supervision of labels is incorporated into topic modeling for SLTM.

the mapping of topics to labels is unconstrained for most existing supervised topic models, which renders many coherent topics being generated outside labels.


The most relevant work to SLTM is the supervised Neural Topic Model (sNTM) for both classification and regression tasks (Cao et al., 2015), which constructed two hidden layers to generate the ngram topic and document-topic representations.

different from our SLTM using bagof-words methods, sNTM adopted fixed embeddings trained on external resources (Mikolov et al., 2013).


On one hand, a label-specific word embedding is introduced for predicting labels in SLTM according to Equation 10.

other supervised topic models for both categorical and real-valued label prediction tasks infer labels for unlabeled documents by topic distributions directly, in which, topic distributions of unlabeled documents are learned without the supervision of labels.


(2009) showed that the Dirichlet prior is important to producing interpretable topics.

it is hard to apply the Dirichlet prior to AEVB directly.


BTM models the word co-occurrence explicitly by directly counting the word-pairs in a text window.

using one-hot encoding for biterms may lose the transitive co-relations.


So aggregating documents in AVITM can not enhance the input feature.

our model uses GCN to capture the transitivity of biterms and can benefit from the sampling strategy a lot.


1 Typical domain adaptation methods are designed to transfer supervision from a single source domain.

in many practical applications, we have access to multiple sources.


2 To derive α, we first define a point-to-set Mahalanobis distance metric between an example x and a set S: where µ S is the mean encoding of S. In its original form, the matrix M S played the role of the inverse covariance matrix.

computing the inverse of the covariance matrix is both time consuming and numerically unstable in practice.


Consequently, if x is either far away from S (i.e., x is not in the manifold of S) or near the classification boundary, we will get a small e(x, S) indicating a low confidence to the corresponding prediction.

if x is much closer to a specific category of S than other categories, the classifier will get a higher confidence.


As shown in Table 6, the increase of the Twitter data does not benefit the unified multi-source model (uni-MS-A), and even amplifies negative transfer for the Answers and Reviews domains.

the performance of our MoE (MoE-A) model stays stable, consistently increasing with more Twitter, showing robustness in handling negative transfer.


The number of correctlylabeled examples is tallied up and reported.

we hypothesize that it may be worthwhile to use difficulty when evaluating DNNs.


If a model does well on hard examples and poor on easy examples, then can we say that it has really learned anything?

if a model does well on easy items, because a dataset is all easy, have we really "solved" anything?


The traditional assumption that the test data is drawn from the same distribution as the training data, makes it difficult to understand how a model will perform in settings where that assumption does not hold.

if the difficulty of test set data is known, we can better understand what kind of examples a given model performs well on, and specific instances where a model underperforms (e.g.


The key parameter in the FOFE method is the forgetting factor, which is responsible for determining the degree of sensitivity of the encoding with respect to the past context.

the choice of a good value for the forgetting factor could be tricky since both small and large forgetting factors are offering different benefits.


In the original FOFE with just a single forgetting factor, we would have to determine the best trade-off between these two benefits.

the dual-FOFE does not face such issues since it is composed of two FOFE codes: the half of the dual-FOFE code using a smaller forgetting factor is solely optimized and responsible for representing the positional information of all words in the sequence; meanwhile the other half of the dual-FOFE code using a larger forgetting factor is optimized and responsible for maintaining the long-term dependency of past context.


Recent work has shown that recurrent neural networks (RNNs) can implicitly capture and exploit hierarchical information when trained to solve common natural language processing tasks (Blevins et al., 2018) such as language modeling (Linzen et al., 2016; Gulordava et al., 2018) and neural machine translation (Shi et al., 2016).

the ability to model structured data with non-recurrent neural networks has received little attention despite their success in many NLP tasks (Gehring et al., 2017; Vaswani et al., 2017).


The works of (Yang and Cardie, 2013) and (Li et al., 2010) are similar to (Jin et al., 2009).

these works only take pre-defined features into account and can not find new features.


Yet to date, textbased empathy prediction has the following major limitations: It underestimates the psychological complexity of the phenomenon, adheres to a weak notion of ground truth where empathic states are ascribed by third parties, and lacks a shared corpus.

this contribution presents the first publicly available gold standard for empathy prediction.


The above contributions, in addition to emoji similarity datasets (Barbieri et al., 2016;Wijeratne et al., 2017) or emoji sentiment lexicons (Novak et al., 2015;Wijeratne et al., 2016;Kimura and Katsurai, 2017;Rodrigues et al., 2018), have paved the way for better understanding the semantics of emojis.

our understanding of what exactly the neural models for emoji prediction are capturing is currently very limited.


Attentive architectures in NLP, in fact, have recently received substantial interest, mostly for sequenceto-sequence models (which are useful for machine translation, summarization or language modeling), and a myriad of modifications have been proposed, including additive (Bahdanau et al., 2015), multiplicative (Luong et al., 2015) or self (Lin et al., 2017) attention mechanisms.

standard attention mechanisms only tell us which text fragments are considered impor- Figure 1: A classic attention network (top), and our attentive label-wise network (bottom), with a specific attention module for each label.


This is often done via a standard RNN decoder that operates on a linearized target tree structure.

it is an open question of what specific linguistic formalism, if any, is the best structural representation for NMT.


ther through syntactic encoders Eriguchi et al., 2016), multi-task learning objectives (Chen et al., 2017;Eriguchi et al., 2017), or direct addition of syntactic tokens to the target sequence (Nadejde et al., 2017;Aharoni and Goldberg, 2017).

these syntax-aware models only employ the standard decoding process of seq2seq models, i.e.


Ideally, this distribution will be focused around zero, indicating that the MT system is generating translations about the same length as the reference.

the distribution of TrDec-con is more spread out than TrDec-binary, which indicates that it is more difficult for TrDec-con to generate sentences with appropriate target length.


Currently, NMT models are usually trained with the word-level loss (i.e., cross-entropy) under the teacher forcing algorithm (Williams and Zipser, *Corresponding Author 1989), which forces the model to generate translation strictly matching the ground-truth at the word level.

in practice it is impossible to generate translation totally the same as ground truth.


Greedy search together with the word-level loss is very similar with the scheduled sampling(SS).

ss is inconsistent with the word-level loss since the word-level loss requires strict alignment between hypothesis and reference, which can only be accomplished by the teacher forcing algorithm.


compare crowdsourced to "expert" ratings on machine translations from WMT 2012, concluding that, with proper quality control, "machine translation systems can indeed be evaluated by the crowd alone."

it is unclear whether this finding carries over to translations produced by NMT systems where, due to increased fluency, errors are more difficult to identify (Castilho et al., 2017a), and concurrent work by Toral et al.


For the following systems we observe a very small increase in APT score for each of the two weight settings we consider, when alignment heuristics are applied: UU-HARDMEIER (+0.8), ITS2 (+0.8), BASELINE (+0.8), YANDEX (+0.8), and NYU (+0.4).

these small improvements are not sufficient to affect the system rankings.


Some of these issues could be addressed by incorporating knowledge of pronoun function in the source language, of pronoun antecedents, and of the wider context of the translation surrounding the pronoun.

whilst we might be able to derive language-specific rules for some scenarios, it would be difficult to come up with more general or language-independent rules.


From the results, we observe that integrating few-shot learning methods into CNN significantly outperforms CNN/PCNN with finetune or kNN, which means adapting fewshot learning methods for RC is promising.

there are still huge gaps between their performance and humans', which means our dataset is a challenging testbed for both relation classification and few-shot learning.


We thereby consider ALT as the baseline for multitask learning in our work.

we argue that this baseline is not effective enough to transfer the knowledge from the WSD dataset to ED in our case.


One the one hand, this representation matching schema helps the two models to communicate to each other so the knowledge from one model can be passed to the other one.

the use of two separate models leaves a flexibility for the models to induce the task-specific structures.


This difficulty makes the co-reference resolution model either prediction a wrong antecedent mention, or cannot find any co-reference.

with ASL, the model learns the semantics of pronouns with an attention to words in other sentences.


Word embedding models have become a fundamental component in a wide range of Natural Language Processing (NLP) applications.

embeddings trained on human-generated corpora have been demonstrated to inherit strong gender stereotypes that reflect social constructs.


The standard cross-entropy loss penalizes the model whenever it fails to produce the exact word from the ground truth data used for training.

in many NLP tasks that deal with generating text from semantic representation, recovering the exact word is not necessarily optimal, and often generating a near-synonym or just a semantically close word is nearly as good or even better from the point of view of model performance.


These works replace mean estimates of embeddings with Gaussian distributions, similar to our proposal here.

they arrive at this differently; Vilnis and McCallum (2017) from the energy-based learning (LeCun et al., 2006), and Brazinskas et al.


So too, the largest DBE drift ("uk") is insignificant once you take into account the covariance structure.

cosine Similarity vs. KL Divergence to cosine distance, our proposed method allows computation of the KLD between two vectors that takes into account their covariance.


Then, a morpheme dictionary of Sanskrit words is used with other heuristics to remove infeasible word split combinations.

none of the approaches address the fundamental problem of identifying the location of the split before applying the rules, which will significantly reduce the number of rules that can be applied, hence resulting in more accurate splits.


It is to be noted that B-RNN-A is the same as DD-RNN without the location decoder.

the accuracy of DD-RNN is 14.7% more than that the B-RNN-A and consistently outperforms B-RNN-A on almost all word lengths ( Figure 5).


Presence of such compound words will increase the vocabulary size exponentially and hinder the translation process.

as a pre-processing step, if all the compound words are split before training a translation model, the number of unique words in the vocabulary reduces which will ease the learning process.


For generative approaches, typical statistical models includes Hidden Markov Model (HMM) (Chen et al., 2014), Hierarchical Dirichlet Process (HDP) (Goldwater et al., 2009) and Nested Pitman-Yor Process (NPY) (Mochihashi et al., 2009).

none of them can be easily extended into a neural model.


Figure 1 illustrates how SLMs work with a candidate segmentation.

in unsupervised scheme, the given sentences are not segmented.


Probably because of this, there is very little literature or understanding of the effect of order among the training examples-strict ordering of examples has simply been known to be undesirable.

as neural network approaches increasingly dominate in performance across many NLP tasks, the notion of random shuffling has become overshadowed by that of computational efficiency.


They empirically compare their efficiency on two translation tasks and find that some strategies in wide use are not necessarily optimal for accuracy and convergence-wise.

to the work described here however, one of the sorting strategies produced best results, though no comparison was made with the original ordering of examples.


We use a simple neural entailment model, Decomposable Attention (Parikh et al., 2016), one of the state-of-the-art models on the SNLI entailment dataset (Bowman et al., 2015).

our architecture can just as easily use any other neural entailment model.


The task of the Aggregator network is to combine these to produce a single entailment score.

we found that using only the final predictions from the three modules was not effective.


Neural models have shown several state-ofthe-art performances on Semantic Role Labeling (SRL).

the neural models require an immense amount of semantic-role corpora and are thus not well suited for lowresource languages or domains.


Improvements of SRL system via use of syntactic constraints is consistent with other observations (Punyakanok et al., 2008).

all previous works enforce syntactic consistency only during decoding step.


The performance of the structured prediction drops rapidly when the noise in the parse information is introduced (x column of Table 4).

ssL was trained on CoNLL2012 data where about 10% of the gold sRL-spans do not match with gold parse-spans and even when we increase noise level to 20% the performance drop was only around 0.1 F1 score.


Users of the system typically have a general understanding of its purpose, so the input will revolve around the correct topic of air travel.

they are unlikely to know the limits of the system's functionality, and may provide inputs for which the expected action is beyond its capabilities, such as asking to change seats on a flight reservation.


One might attempt self-training (McClosky et al., 2006), where new instances are generated by applying a trained model to unannotated data, using high-confidence predictions as ground truth labels.

in such a scheme, the expectation is that the unlabelled text already contains errors, which is not usually the case for most freely available text such as Wikipedia articles as they strive towards correctness.


This approach follows the previous works on grammar induction using non-neural models where the entire dataset is used for training (Klein and Manning, 2002).

this implies that the parsing results of PRPN-UP may not be generalizable in the way usually expected of machine learning evaluation results.


We would expect a similar result for Telugu.

telugu treebank is entirely composed of sentences from a grammar book which may not be expressive and diverse.


It's not hard to imagine how such systems could be useful.

to generic text summarization, RC systems could answer targeted questions about specific documents, efficiently extracting facts and insights.


On first glance the the length-20 passages in CBT, might suggest that success requires reasoning over all 20 sentences to identify the correct answer to each question.

it turns out that for some models, comparable performance can be achieved by considering only the last sentence.


Such approach ensures a diversity and full coverage of all possible dialogue outcomes within a certain domain.

the naturalness of the dialogue flows relies entirely on the engineered set-up of the user and system bots.


At each generation step, only the already produced sequence is taken into account.

future and not-yet-produced tokens can also be highly relevant when choosing the current token.


The self-attention module of a Transformer network treats a sequence bidrectionally as a fully connected graph of tokens -when a token is produced all other tokens are taken into consideration.

this requires the entire sequence to be known a priori and when a Transformer is used for sequence generation, the self-attention process only includes previously produced tokens (Vaswani et al.


(2017), Jain and Wallace's requisite for attention distributions to be used as explanation is that there must only exist one or a few closely-related correct explanations for a model prediction.

doshi-Velez and Kim (2017) caution against applying evaluations and terminology broadly without clarifying taskspecific explanation needs.


sampled data to evaluate the comparative effectiveness of different AL strategies.

collection of such additional data would defeat the purpose of AL, i.e., obviating the need for a large amount of supervision.


This coupling is problematic because manually labeled data tends to have a longer shelf life than models, largely because it is expensive to acquire.


For example, AL methods -both in the standard and acquisition/successor settings -perform much more reliably on the Subjectivity dataset than any other.

aL performs consistently poorly on the TREC dataset.


Specifically, deep learning models, which became a prominent tool in many data driven tasks in recent years, require large datasets to work well.

many tasks require manual annotations which are relatively hard to obtain at scale.


Mann and McCallum (2007) and following work take the base classifier p θ (y|x) to be a logistic regression classifier, for which they manually derive gradients for the XR loss and train with LBFGs (Byrd et al., 1995).

nothing precludes us from using an arbitrary neural network instead, as long as it culminates in a softmax layer.


For each KB, we first use an integrated entity linker to retrieve relevant entity embeddings, then update contextual word representations via a form of word-to-entity attention.

to previous approaches, the entity linkers and selfsupervised language modeling objective are jointly trained end-to-end in a multitask setting that combines a small amount of entity linking supervision with a large amount of raw text.


For a typical 25 token sentence, approximately 2M entity embedding parameters are actually used.

bERT LARGE uses the majority of its 336M parameters for each input.


For example, if word vectors were perfectly isotropic (i.e., directionally uniform), then SelfSim (w) = 0.95 would suggest that w's representations were poorly contextualized.

consider the scenario where word vectors are so anisotropic that any two words have on average a cosine similarity of 0.99.


As noted earlier, contextualized representations are more contextspecific in upper layers of ELMo, BERT, and GPT-2.

how does this increased contextspecificity manifest in the vector space?


We also experiment with two correlation measures: Pearson's (r) and Kendall's rank (τ ) correlation coefficients.

to linear regression and Pearson's correlation coefficient, Kendall's tau is non-parametric and resistant to outliers (Kendall, 1948).


Consistently, on vectors with few outliers (word2vec), Pearson's r achieves the same performance as rank correlations even without winsorization.

unlike outliers, positive (negative) skew of max-(min-) pooled vectors does not seem to hurt Pearson's r on STS tasks.


A typical reward function on policy learning consists of a small negative penalty at each turn to encourage a shorter session, and a large positive reward when the session ends successfully if the agent completes the user goal.

specifying an effective reward function is challenging in task-oriented dialog.


For example, it is inappropriate to book a 3-star hotel without confirming with the user at the first turn in Table 1.

an explicit user goal is essential to evaluate the task success in the reward design, but user goals are hardly available in real situations (Su et al., 2016).


We also observe that GP-MBCM tries to provide many dialog acts to avoid the negative penalty at each turn, which results in a very low inform F1 and short dialog turns.

as explained in the introduction, a shorter dialog is not always the best.


Referring to Figure 3 (a), only using hop1 selector is not better than using multiple selectors.

the performance does not increase when k > 3.


Intuitively, when γ is too large, the selectors will filter out too much context, which may hurt performance.

when γ is too small, the selectors do not work very well.


Previous research on empathetic dialogue systems has mostly focused on generating responses given certain emotions.

being empathetic not only requires the ability of generating emotional responses, but more importantly, requires the understanding of user emotions and replying appropriately.


Table 1 shows an conversation from the empathetic-dialogues dataset (Rashkin et al., 2018) about how an empathetic person would respond to the stressful situation the Speaker has been through.

despite the importance of empathy and emotional understanding in human conversations, it is still very challenging to train a dialogue agent able to recognize and respond with the correct emotion.


With the additional supervision on user emotions, multi-task training improves both Empathy and Relevance score, but it still degrades Fluency.

moEL achieves the highest  Empathy and Relevance score.


For example, in the fifth example in Figure 4, the model fails to detect the real emotion of speaker as the context contains "I was pretty surprised" in its last turn.

the last three rows of the heatmap indicate that the model learns to leverage multiple listeners to produce an empathetic response.


As mentioned in section 3.3.1, we adopt the memory network to train our KB-retriever.

in the Seq2Seq dialogue generation, the training data does not include the annotated KB row retrieval results, which makes supervised training the KBretriever impossible.


A common practice is to apply RL on a neural sequence-to-sequence (seq2seq) framework with the action space being the output vocabulary in the decoder.

it is difficult to design a reward function that can achieve a balance between learning an effective policy and generating a natural dialog response.


Hence, we feed the conversation to a bidirectional gated recurrent unit (GRU) (Chung et al., 2014).

like most of the current models, we also ignore intent modelling, topic, and personality due to lack of labelling on those aspects in the benchmark datasets.


In theory, RNNs like long short-term memory (LSTM) (Hochreiter and Schmidhuber, 1997) and GRU should propagate long-term contextual information.

in practice it is not always the case (Bradbury et al., 2017).


Finally, utterance representation is obtained by feeding the current utterance as query to two distinct memory networks for both speakers.

this model can only model conversations with two speakers.


The task of detecting emotions in textual conversations leads to a wide range of applications such as opinion mining in social networks.

enabling machines to analyze emotions in conversations is challenging, partly because humans often rely on the context and commonsense knowledge to express emotions.


One major reason is that learning long dependencies using gated RNNs may not be effective enough because the gradients are expected to propagate back through inevitably a huge number of utterances and tokens in sequence, which easily leads to the vanishing gradient problem (Bengio et al., 1994).

when the utterance-level LSTM in cLSTM is replaced by features extracted by CNN, i.e., the CNN+cLSTM, the model performs significantly better than cLSTM on long conversations, which further validates that modelling long conversations using only RNN models may not be sufficient.


Our KET variants KET SingleSelfAttn and KET StdAttn perform comparably with the best baselines on all datasets except IEMOCAP.

both variants perform noticeably worse than KET on all datasets except EC, validating the importance of our proposed hierarchical self-attention and dynamic context-aware affective graph attention mechanism.


A relevant emotion ranking framework was proposed in (Yang et al., 2018) to predict multiple relevant emotions as well as the rankings based on their intensities.

existing emotion detection approaches do not model the events in texts which are crucial for emotion detection.


proposed a model with several constraints using non-negative matrix factorization based on emotion lexicon for multiple emotion detection.

these approaches often suffer from low recall.


In particular, the attention-based recurrent neural networks (RNNs) (Schuster and Paliwal, 2002;Yang et al., 2016) prevail in text classification.

these approaches ignore the latent events in texts thus fail to attend on event-related parts.


(2019b) generated tips by considering 'persona' information which can capture the language style of users and characteristics of items.

these works use whole reviews or tips as training examples, which may not be appropriate due to the quality of review text.


Unfortunately, most websites do not provide such finegrained information.

our work identifies justifications from reviews, uses them as training examples and shows these are better data source for explainable recommendation via extensive experiments.


Although recent studies on multi-task learning framework suggest that closely related tasks can improve each other mutually from separated supervision information (Ma et al., 2018;Cerisara et al., 2018;, the acquisition of sentence (or utterance)-level sentiment labels, which is required by multi-task learning, remains a laborious and expensive endeavor.

coarse-grained document (or dialogue)-level annotations are relatively easy to obtain due to the widespread use of opinion grading interfaces (e.g., ratings).


Recently, Multiple Instance Learning (MIL) framework is adopted for performing documentlevel and sentence-level sentiment classification simultaneously while only using document-level sentiment annotations (Zhou et al., 2009;Wang and Wan, 2018).

these models are trained based on plain textual data which are in a much simpler form than our multi-turn dialogue structure.


More recently, some researchers started to explore the utterance-level structure for sentiment classification, such as modeling dialogues via a hierarchical RNN in both word level and utterance level (Cerisara et al., 2018) or keeping track of sentiment states of dialogue participants (Majumder et al., 2018).

none of these works can do dialogue-level satisfaction classification and utterance-level sentiment classification simultaneously.


In the simplest case, satisfaction polarities C = {well satisfied, met, unsatisfied} can be computed by averaging all predicted sentiment distributions of customer utterances as y = 1 M t∈[1,M ] p ct .

it is a crude way of combining sentiment distributions uniformly, as not all distributions convey equally important sentiment clues.


In-depth Analysis: CAMIL f ull is only trained based on satisfaction labels, thus the laborious acquisition of sentiment labels is unnecessary.

we would point out that lack of sentiment labels will inevitably lead to difficulties on identifying positive/negative utterances from those neutral ones.


Here our baseline system takes the standard approach, using the 1-best parser output tree D T as features.

our proposed model uses the most confident parser forest D F as features.


On the one hand, keeping the whole search space gives 100% recall, but introduces maximum noise.

using the 1-best dependency tree can result in low recall given an imperfect parser.


For connectivity, KBESTEISNER guarantees to generate spanning forests.

the connectivity ratio for the forests produced by EDGEWISE drops when increasing the threshold .


The main reason may be that EDGEWISE generates denser forests, providing richer features.

kBESTEISNER shows a marginal improvement by increasing k from 5 to 10.


These methods take advantage of supervised or distantlysupervised data to learn neural sentence encoders for distributed representations, and have achieved promising results.

these methods cannot handle the open-ended growth of new relation types in the open-domain corpora.


Finally, we want to explain the reason why we do not use some other common clustering methods like K-Means, Mean-Shift and Ward's (Ward Jr, 1963) method of HAC: these methods calculate the centroid of several points during clustering by merely averaging them.

the relation vectors in our model are high-dimensional, and the distance metric described by RSN is non-linear.


A previous OpenRE work reports performance on an unpublic dataset called NYT-FB (Marcheggiani and Titov, 2016).

it has several shortcomings compared with FewRel-distant.


Recent developments in the field often take an embeddingbased approach to model the structural information of KGs so that entity alignment can be easily performed in the embedding space.

most existing works do not explicitly utilize useful relation representations to assist in entity alignment, which, as we will show in the paper, is a simple yet effective way for improving entity alignment.


There exist a variety of methods (Bordes  et Socher et al., 2013;Wang et al., 2014;Trouillon et al., 2016;Nguyen et al., 2018) that have been proposed to learn good embeddings for entities and relations.

embedding of uncommon relation or entities can not learn a good representation due to the data insufficiency.


During meta-training phase, it takes O as inputs and learns latent patterns for triplets.

during the training stage of the meta-testing phase, instead of learning latent patterns, the triplet generator performs triplet aug- Step 1: encoding process of relation descriptions Step  Step 2: computation of entity traits mentation by generating extra K sets of embeddings G = {(g h , g r , g t )}.


In KG, if an entity is involved in multiple relations, it is natural that different relations are more relevant to different parts in the description of the entity.

existing works using textual descriptions have not tackled this issue effectively.


We can construct them from online resources, such as the anchors in Wikipedia.

the following natures of WL data make learning name tagging from them more challenging: Partially-Labeled Sequence Automatically derived WL data does not contain complete annotations, thus can not be directly used for training.


Another line of work is to replace CRFs with Partial-CRFs (Täckström et al., 2013), which assign unlabeled words with all possible labels and maximize the total probability Shang et al., 2018).

they still rely on seed annotations or domain dictionaries for high-quality training.


According to a manually defined mapping Γ(Y) → C (e.g., Γ(ORG) =Organizations), we denote all the classes and their children with the same type (e.g., ORG).


On one hand, it predicts each word's label separately, naturally addressing the issue of inconsecutive labels.

we only focus on the labeled words, so that the module is robust to the noise since most noise arises from the unlabeled words, and enjoy an efficient training procedure.


Prior distribution and local contexts, either in the form of hand-crafted features (Ratinov et al., 2011;Shen et al., 2015) or dense embeddings (He et al., 2013;Nguyen et al., 2016;Francis-Landau et al., 2016), play key roles in distinguishing different candidates.

in many cases, local features can be too sparse to provide sufficient information for disambiguation.


To alleviate this problem, various collective EL models have been proposed to globally optimize A traditional global EL model jointly optimizes the linking configuration after iterative calculations over all mentions, which is computationally expensive.

the DCA process only requires one pass of the document to accumulate knowledge from previously linked mentions to enhance fast future inference.


entity disambiguation for dynamic web data like Twitter).

the computational complexity of our model is O(T × |E| × I × K), where K is the key hyper-parameter described in Section 3 and is usually set to a small number.


Thus, such mentions will always introduce wrong information to the model, which leads to a worse performance.

the AIDA-B dataset does not have such situations.


As Figure  (4.c) shows, when |E| increases, the running time of these two global EL models increases shapely, while our DCA model grows linearly.

we also observed that the resources required by the DCA model are insensitive to |E|.


Both approximation methods iteratively improve the global assignment, but are still computationally expensive with unbounded number of iterations.

the proposed DCA method only requires one pass through the document.


We adopt graph convolutional networks (GCN) (Kipf and Welling, 2017; Marcheggiani and Titov, 2017) to encode graph structures over the input data, applying graph convolution operations to generate entity and word representations in a latent space.

to other encoders such a Tree-LSTM (Tai et al., 2015), GCN can cover more complete contextual information from dependency parses because, for each word, it captures all parse tree neighbors of the word, rather than just the child nodes of the word.


Mean-selector (Lin et al., 2016;Ye et al., 2017): The bag encoding is computed as Max-selector (Jiang et al., 2016): The j th element of bag encoding x is computed as Attention-selector Attention mechanism is extensively used for sentence selection in relation extraction by weighted summing of the sentence vectors, such as in (Lin et al., 2016;Ye et al., 2017;Su et al., 2018).

all these works assume that the labels are correct and only use the golden label embeddings to select sentences at training stage.


For the first event, the entity 1 "[SHARE1]" is the correct Pledged Shares at the sentence level (ID 5).

due to the capital stock increment (ID 7),  Figure 2: A document example with two Equity Pledge event records whose arguments scatter across multiple sentences, where we use ID to denote the sentence index, substitute entity mentions with corresponding marks, and color event arguments outside the scope of key-event sentences as red.


The most recent work, DCFEE , attempted to explore DEE on ChFinAnn, by employing distant supervision (DS) (Mintz et al., 2009) to generate EE data and performing a two-stage extraction: 1) a sequence tagging model for SEE, and 2) a key-event-sentence detection model to detect the key-event sentence, coupled with a heuristic strategy that padded missing arguments from surrounding sentences, for DEE.

the sequence tagging model for SEE cannot handle multi-event sentences elegantly, and even worse, the context-agnostic argumentscompletion strategy fails to address the argumentsscattering challenge effectively.


On the other hand, another recent work (Zeng et al., 2018b) showed that directly labeling event arguments without trigger words was also feasible.

they only considered the SEE setting and their methods cannot be directly extended to the DEE setting, which is the main focus of this work.


(2018) proposes the nugget proposal networks (NPN) in terms of this issue, which uses a neural network to model character compositional structure of trigger words in a fix-sized window.

the mechanism of the NPN limits the scope of trigger candidates within a fix-sized window, which is inflexible and suffering from the problem of trigger overlaps.


All approaches except ours give lower recall rates in the trigger-mismatch part than in the trigger-match part.

our model could robustly address the word-trigger mismatch problem, reaching the best results on both parts of the two datasets.


These methods have achieved great success in English datasets.

in languages without delimiters, such as Chinese, the mismatch of word-trigger become significantly severe.


(2018) proposes NPN, a neural network based method to address the issue.

the mechanism of NPNs limits the scope of trigger candidates within a fix-sized window, which will cause two problems in the progress.


But in this work, word disambiguation datasets are necessary.

our model can solve both word-trigger mismatch and trigger polysemy problems at the same time.


For example, a token can be tagged with B-P ER, where B indicates the boundary of an entity and P ER indicates the corresponding entity categorical label.

when entities are nested within one another, single-layer sequence labeling models can not ex-tract both entities simultaneously.


To generate a triplet, they first generated the relation, then they copy the first entity and the second entity from the source sentence.

none of them have considered the extraction order of multiple triplets in a sentence.


It ranks all the entities in the graph for their likelihood to be the missing entity and the rank assigned to the true missing entity is considered.

while this is suitable for ontological KGs, it is not valid for our setting.


Table 1 shows that in both the datasets, on an average, the number of train triples for each NP and RP is less than 2.

fB15k (Bordes et al., 2013), an ontological KG, has on an average 32 triples for each entity and 360 triples for each relation.


All the above RE models are supervised machine learning models that need to be trained with large amounts of manually annotated RE data to achieve high accuracy.

annotating RE data by human is expensive and timeconsuming, and can be quite difficult for a new language.


Spanish, Italian, Portuguese, German (in conventional typology) and Chinese   also belong to the SVO language family, and our approach achieves over 70% relative accuracy for these languages.

japanese belongs to the SOV (Subject, Object, Verb) language family and Arabic belongs to the VSO (Verb, Subject, Object) language family, and our approach achieves lower relative accuracy for these two languages.


The conventional distant supervision strategy only exploits instances that directly mention a target entity pair, and because of this, we refer to it as 1-hop distant supervision.

there are a large number of Web tables that contain relational facts about entities (Cafarella et al., 2008;Venetis et al., 2011;Wang et al., 2012).


To the best of our knowledge, there has been no existing work on joint event-temporal relation extraction.

the idea of "joint" has been studied for entityrelation extraction in many works.


For densely annotated data, the micro-average metric should share the same precision, recall and F1 scores.

since our joint model includes NONE pairs, we follow the convention of IE tasks and exclude them from evaluation.


HMCN also has the same issue, resulting in Macro-F1 lower than 10 when combining with some base models.

hiLAP outperforms the baselines significantly in Macro-F1, which implies that our method is bet- Table 4: Performance comparison on Functional Catalogue and Gene Ontology.


We found, for example, 29,186/781,265 (3.74%) predictions of TextCNN have inconsistent on RCV1.

hiLAP ensures 0% label inconsistency without the need of post-processing, because its predictions are always valid sub-trees of the label hierarchy (refer to Fig.


Normally, each word's representation is constructed by counting all its context features.

for the polysemic word which contains multiple senses, the context features of different senses are mixed together, leading to inaccurate word representation.


Moreover, the accuracy was further improved by attention-based neural networks [Lin et al., 2017;Vaswani et al., 2017;Yang et al., 2016].

these models are less efficient than capsule networks.


The word 'wonder' in the first sample sentence means something that fills you with surprise and admiration, which shows a very positive sentiment.

the polysemic word 'wonder' in the second and third sentences means to think about something and try to decide what is true, which is neutral in sentiment.


The projected representations for the same sense are similar, the Euclidean distance is 0.23 (row 2,3).

for the different senses, the Euclidean distance is 1.12 (row 1,2).


Among them, deep learning-based methods such as CNN (Liu et al., 2017;Kurata et al., 2016), RNN (Liu et al., 2016), combination of CNN and RNN (Lai et al., 2015;Chen et al., 2017), attention mechanism (Yang et al., 2016;You et al., 2018), (Adhikari et al., 2019) and etc., have achieved great success in document representation.

most of them only focus on document representation but ignore the correlation among labels.


In dense data, each label has sufficient documents, therefore, self-attention can sufficiently obtain label-specific document representation.

label text is helpful to extract the semantic relations between labels and documents.


The dominant text classification models in deep learning (Kim, 2014;Zhang et al., 2015a;Yang et al., 2016; require a considerable amount of labeled data to learn a large number of parameters.

such methods may have difficulty in learning the semantic space in the case that only few data are available.


In text classification, Nguyen (2018) shows that automatic evaluation based on word deletion moderately correlate with human-grounded evaluations that ask crowdworkers to infer machine predictions based on explanations.

explanations that help humans infer machine predictions may not actually help humans make better decisions/predictions.


Similarly, Serrano and Smith (2019) show that attention is not a fail-safe indicator for explaining machine predictions based on intermediate representation erasure.

wiegreffe and Pinter (2019) argue that attention can be explanation depending on the definition of explanations (e.g., plausibility and faithfulness).


If this were true, the choice of model/method would have mattered little for visualizing important features.

a low similarity poses challenges for choosing which model/method to use for displaying important features.


Consistent with H3b, adjectives are more important in sentiment classification than in deception detection.

to our hypothesis, we found that pronouns do not always play an important role in deception detection.


CNN wrongly captures key phrases British Energy and the nuclear generator and thus misclassifies the example into World.

our Attention-CNN is able to correctly classify it into Business.


These benchmarks typically assume large annotated training sets, little mismatch between training and test distributions, relatively clean data, and a lack of adversarial examples (Zue et al., 1990;Marcus et al., 1993;Deng et al., 2009;Lin et al., 2014).

when conditions are not ideal for discriminative classifiers, generative classifiers can actually perform better.


Recent work in neural networks has shown that introducing latent variables leads to higher representational capacity (Kingma and Welling, 2014;Chung et al., 2015;Burda et al., 2016;Ji et al., 2016).

unlike variational autoencoders (Kingma and Ba, 2015) and related work that use continuous latent variables, our model is more similar to recent efforts that combine neural architectures with discrete latent variables and end-to-end training (Ji et al., 2016;Kim et al., 2017;Kong et al., 2017;Chen and Gimpel, 2018;Wiseman et al., 2018, inter alia).


The hidden topic model extracts topics purely relying on the reviewer profile, so the topic vectors can be regarded as a summary of the reviewers' research interest.

the common topic vectors are selected based on the knowledge of both the submission and the reviewer's profile, which are expected to capture the topical overlap between the two.


Haxby et al., 2001;Kriegeskorte et al., 2006).

the full power of linear decoding with fMRI remains unknown within language neuroscience and elsewhere.


While these brain mapping studies have detected particular summary features of syntactic computation in the brain, these summary features do not constitute complete proposals of syntactic processing.

each of the models trained in this paper constitutes an independent candidate algorithmic description of sentence representation.


Some of the discovered inconsistencies, despite being factually incorrect, could be rationalized by humans.

in many cases, the errors were substantial and could have severe repercussions if presented as-is to target readers.


Lead-3 is a strong baseline that exploits the described layout bias.

there is still a large gap between its performance and an upper bound for extractive models (extractive oracle).


When focusing on the neural pipeline approaches, we found that in all the steps up to Text Structuring, the recurrent networks retained more information than the Transformer.

68% of the Transformer's text trials contained all the input triples, against 67% of the GRU's trials.


As shown in Figure 1, BERTScore (precision/recall) can be intuitively viewed as hard alignments (one-to-one) for words in a sentence pair, where each word in one sequence travels to the most semantically similar word in the other sequence.

moverScore goes beyond BERTScore as it relies on soft alignments (manyto-one) and allows to map semantically related words in one sequence to the respective word in the other sequence by solving a constrained optimization problem: finding the minimum effort to transform between two texts.


Apparently, strict matches on surface forms seems reasonable for extractive summarization datasets.

we still see that our word mover metrics, i.e., WMD-1+BERT+MNLI+PMeans, perform better than or come close to even the supervised metric S 3 best .


We speculate that current contextualizers are poor at representing named entities like hotels and place names as well as numbers appearing in system and reference texts.

best correlation is still achieved by our word mover metrics combining contextualized representations.


The major improvements come from contextualized BERT embeddings rather than word2vec and ELMo, and from fine-tuning BERT on large NLI datasets.

we also observed that soft alignments (MoverScore) marginally outperforms hard alignments (BERTScore).


Its selector is largely deterministic, with a lowest entropy value among all models.


This multilingual model still relies on copying to relate each labeled output sentence to its corresponding input counterpart.

unlike (i), it has the advantage of sharing parameters among languages.


The frames define a common, prototypical argument structure while at the same time providing new concept-specific information.

to PropBank, which defines enumerative semantic roles, VerbAtlas comes with an explicit, cross-frame set of semantic roles linked to selectional preferences expressed in terms of WordNet synsets, and is the first resource enriched with semantic information about implicit, shadow, and default arguments.


Its application goes well beyond the annotation of corpora: in fact, it was also adopted for the Abstract Meaning Representation (Banarescu et al., 2013), a semantic language that aims at abstracting away from cross-lingual syntactic idiosyncrasies, and NomBank (Meyers et al., 2004), a resource which provides argument structures for nouns.

propBank's major drawback is that its roles do not explicitly mark the type of semantic relation with the verb, instead they just enumerate the arguments (i.e., Arg0, Arg1, etc.).


Second, the weights in SIF (and uSIF) are calculated from the statistic of vocabularies on very large corpus (wikipedia).

the weights in GEM are directly computed from the sentences themselves along with the dataset, independent with prior statistical knowledge of language or vocabularies.


The image shows him riding a bike, indicating that he was riding a bike when he tweeted thus he was in possession of a bike.

if the picture were a screenshot of his Twitter posting statistics, Arnold most likely would not be in possession of a bike when tweeting, but rather sharing a log of his previous trips with his followers.


The seen test set consists of dialogues set in the same world (set of locations) as the training set, thus also consists of characters, objects, and personas that can appear in the training data.

the unseen test set is com-Category: Graveyard Description: Two-and-a-half walls of the finest, whitest stone stand here, weathered by the passing of countless seasons.


The standard approach to tackle this issue has been to make certain design choices explicit, such as to enforce a particular policy with respect to overlapping mentions, or common entities, etc., when labeling an EL dataset or performing evaluation.

the appropriate policy may depend on the particular application, setting, etc.


The first three should be tagged when the mentions are equal (Michael Jackson), shorter (Jackson) or longer (Michael Joseph Jackson), respectively, than the primary label of their corresponding KB-entity (wiki:Michael Jackson).

alias is used for mentions that vary from the primary label of the KB (King of Pop).


For a given system result S, gold standard G and its fuzzy version G * , we propose that precision be computed in the traditional way for the crisp version of the gold standard -P = |T P | -with the intuition that false positives proposed by the system (type I error) be weighted equally: if the system proposes an annotation, it should be correct, independently of the type of annotation.

a gold standard annotation not proposed by the system may be due to different design choices; we hence propose to use a fuzzy recall measure with respect to G * , namely R * = a∈S µ G * (a) a∈G µ G * (a) , thus applying different costs for missing annotations (type II errors) depending on the annotation in question.


Most Open IE systems extract binary relations using domain-independent syntactic and lexical constraints.

systems specialized in other syntactic constructions were also developed, such as noun-mediated relations (Pal and Mausam, 2016), n-ary relations (Akbik and Löser, 2012), nested propositions (Bhutani et al., 2016) and numerical Open IE (Saha et al., 2017a).


One strategy for tuple matching would be to enforce an exact match by matching the boundaries of the extracted and benchmark tuples in text.

as noted in earlier works Schneider et al., 2017), this method penalizes different but equally valid arguments, which are resulted from different annotation styles employed by different Open IE systems.


As each of the unsupervised OpenIE systems has it's own rules to extract different relations, applying only one system might miss other potential relations that can be extracted by other Open IE systems.

since SenseOIE learns from multiple existing Open IE systems, it can extract many different relation types.


This feature is useful to generate multiple sequences of extractions from a single sentence.

note that this model does not use the results of unsupervised systems as features.


Crosslingual ED aims to tackle this challenge by transferring knowledge between different languages to boost performance.

previous cross-lingual methods for ED demonstrated a heavy dependency on parallel resources, which might limit their applicability.


The original GCNs compute a graph convolution vector for w i at (k+1)th layer by: where and b k L(w i ,v) are parameters of the dependency label L(w i , v) in the kth layer.

retaining parameters for every dependency label is space-consuming and compute-intense (there are approximately 50 labels), in our model, we limit L(w i , v) to have only three types of labels 1) an original edge, 2) a self loop edge, and 3) an added inverse edge, as suggested in (Nguyen and Grishman, 2018).


We discuss five baseline approaches, where the best approach achieves an F1 score of 0.50, significantly outperforming a traditional approach by 79% (0.28).

our best baseline is far from reaching human performance (0.82), indicating our dataset is challenging.


End-to-end systems Miwa and Bansal, 2016) are a promising solution for addressing error propagation.

a major roadblock for the advancement of this line of research is the lack of benchmark datasets.


Our best baseline (Baseline 5) significantly outperforms the standard pipeline approach (Baseline 1) in both the text and link evaluation.

the performance of Baseline 5 is well below the human performance.


Neural Process Networks The most significant prior work on this dataset is the work of .

their data condition differs significantly from ours: they train on a large noisy training set and do not use any of the highquality labeled data, instead treating it as dev and test data.


Pre-training has proven to be effective in unsupervised machine translation due to its ability to model deep context information in cross-lingual scenarios.

the crosslingual information obtained from shared BPE spaces is inexplicit and limited.


Previous approaches benefit mostly from crosslingual n-gram embeddings, but recent work proves that cross-lingual language model pretraining could be a more effective way to build initial unsupervised machine translation models (Lample and Conneau, 2019).

in their method, the cross-lingual information is mostly obtained from shared Byte Piece Encoding (BPE) (Sennrich et al., 2016b) spaces during pre-training, which is inexplicit and limited.


In this way, the model can leverage the cross-lingual information provided by parallel sentences to predict the masked tokens.

for unsupervised machine translation, TLM cannot be used due to the lack of parallel sentences.


Leveraging much more monolingual data from Wikipedia, their work shows a big potential of pre-training for unsupervised machine translation.

the cross-lingual information is obtained mostly from the shared BPE space during their pre-training method, which is inexplicit and limited.


Therefore, there exists no analytical solution to maximize it.

since deep neural network is differentiable, we can update θ by taking a gradient ascent step: The resulting algorithm belongs to the class of generalized EM algorithms and is guaranteed (for a sufficiently small learning rate η) to converge to a (local) optimum of the data log likelihood (Wu, 1983).


LaSyn is able to generate diverse translations that reflect the sentence structure implied by the input POS tags.

in trying to fit the translation into the specified sequence, it deviates somewhat  from the ideal translation.


We find that the translation performance of SEARCH rises with the increase of monolingual corpus size in the beginning.

further enlarging the monolingual corpus hurts the translation performance.


However, further enlarging the monolingual corpus hurts the translation performance.

our approach can still obtain further improvements when adding more synthetic bilingual sentence pairs.


ReLU or similar non linearity functions work well with single neurons.

we find that this squashing function works best with capsules.


Recently many embedding-based approaches were proposed for cross-lingual entity alignment.

almost all of them are based on TransE or its variants, which have been demonstrated by many studies to be unsuitable for encoding multi-mapping relations such as 1-N, N-1 and N-N relations, thus these methods obtain low alignment precision.


Multilingual KGs such as BabelNet (Navigli and Ponzetto, 2012), YAGO3 (Mahdisoltani et al., 2013) and DBpedia (Lehmann et al., 2015) play essential roles in many cross-lingual applications.

for multilingual KGs, each languagespecific part is constructed by different parties with different data sources.


Since such an obviously false triple is "too easy" and can easily obtain low plausibility during training.

a negative triple like (David Hilbert, nationality, F rance) is more valuable, since F rance has similar semantics with Germany, but F rance can't replace Germany.


But when neg is small, the uniform sampling method can't generate enough valuable samples, which seriously hurts the final performance.

our sampling strategy can pay more attention to valuable samples, generating many valuable negative samples even when the amount of total samples is small.


The framework presented in this work, is a general framework that can accommodate other mappings and improvements to the distance functions.

so far to the best of our knowledge, structure preserving mapping such GP outperforms non-linear mappings that change the structure of the underlying space.


The underlying assumption of these approaches is that in-domain and out-ofdomain NMT models share the same parameter space or prior distributions, and the useful out-ofdomain translation knowledge can be completely transferred to in-domain NMT model in a onepass manner.

it is difficult to achieve this goal due to domain differences.


More specifically, at the k-th iteration, we first transfer the translation knowledge of the previous in-domain NMT model θ out trained on D out (Line 6), and then reversely transfer the translation knowledge encoded by θ Obviously, during the above procedure, one of important steps is how to transfer the translation knowledge from one domain-specific NMT model to the other one.

if we directly employ conventional domain transfer approaches, such as fine-tuning, as the iterative dual domain adaptation proceeds, the previously learned translation knowledge tends to be ignored.


The underlying  reason is that these multi-domain models discriminate domain-specific and domain-shared information in encoder, however, their shared decoder are inadequate to effectively preserve domain-related text style and idioms.

our framework is adept at preserving these information since we construct an individual NMT model for each domain.


Extending the study to the multi-agent scenario is feasible and desirable, as multiple agents might supply more reliable and diverse advantages compared to the two-agents scenario.

the agent is expected to learn advantages from each other in the multi-agent scenario, which results in a complex many-to-many learning problem( Figure  1.(b)).


With the above formula, the agent is optimized to the minimization of the model divergence between its own model and the ensemble model.

integrating the above regularization term into the training objective straightforwardly is problematic in practice.


Plain pivot-based transfer outperforms the synthetic data baseline by up to +1.9% BLEU or -3.3% TER.

the pivot adapter or cross-lingual encoder gives marginal or inconsistent improvements over the plain transfer.


Modern sentence-level NMT systems often produce plausible translations of isolated sentences.

when put in context, these translations may end up being inconsistent with each other.


Current state-of-the-art neural machine translation (NMT) uses a deep multi-head selfattention network with no explicit phrase information.

prior work on statistical machine translation has shown that extending the basic translation unit from words to phrases has produced substantial improvements, suggesting the possibility of improving NMT performance from explicit modeling of phrases.


Existing methods mainly focus on developing novel network architectures so as to stabilize gradient back-propagation, such as the fast-forward connection (Zhou et al., 2016), the linear associative unit (Wang et al., 2017), or gated recurrent network variants (Hochreiter and Schmidhuber, 1997;Gers and Schmidhuber, 2001;Cho et al., 2014;Di Gangi and Federico, 2018).

to the above recurrent network based NMT models, recent work focuses on feed-forward alternatives with more smooth gradient flow, such as convolutional networks (Gehring et al., 2017) and selfattention networks (Vaswani et al., 2017).


Neural-network-based models for Machine Translation (MT) have set new standards for performance, especially when large amounts of parallel text (bitext) are available.

explicit word-to-word alignments, which were foundational to pre-neural statistical MT (SMT) (Brown et al., 1993), have largely been lost in neural MT (NMT) models.


In §4 we established that our discriminativelytrained neural aligner outperforms unsupervised baselines, especially on NER spans; in §5 we verified that the alignments it produces can be productively applied a downstream IE task (NER) via dataset projection.

unlike these unsupervised baselines, our aligner requires labelled data on the order of thousands of sentences, and thus cannot be applied to language pairs for which no labelled alignment data exists (most languages).


These studies mainly use capsule network for information aggregation, where the capsules could have a less interpretable meaning.

our model learns what we expect by the aid of auxiliary learning signals, which endows our model with better interpretability.


Popović (2011b) further develop this algorithm into an open-source tool and demonstrates that the detected errors helps to build better evaluation metrics.

the edit distance algorithm is not robust (c. f. Sec.


It is because wrong translation is also likely to get aligned with the source as it can be the translation of the source words in some other contexts.

reference gives us a pointer to the correct word choice in the given context, hence helping determining W label.


Neural machine translation (NMT) has achieved the state-of-the-art results on a mass of language pairs with varying structural differences, such as English-French (Bahdanau et al., 2014;Vaswani et al., 2017) and Chinese-English (Hassan et al., 2018).

so far not much is known about how and why NMT works, which pose great challenges for debugging NMT models and designing optimal architectures.


Punctuation in NMT is understudied since it carries little information and often does not affect the understanding of a sentence.

we find that punctuation is important on English⇒Japanese translation, whose proportion increases dramatically.


In particular, we observe that 2;IMP;PL;Vthe category difficult for Polish-Czech BLI is also among the most challenging for Polish-Spanish.

one of the highest performing categories for Polish-Czech, 3;MASC;PL;PST;V, yields much worse accuracy for Polish-Spanish.


Without the warm-up period and the additional copying tasks, our model's dev accuracy is worse than any of the baselines.

our two-step attention trained with the additional copying task already improves over most baselines without any of the additional biases, with a dev accuracy of 48.


Previous work aims to build a well-formed tree (Tiedemann and Agić, 2016) from source dependencies, solving word alignment conflicts by heuristic rules.

we use partial translation instead to avoid unnecessary noise.


Recently, transition-based top-down parsing with Pointer Networks (Vinyals et al., 2015) has attained state-of-the-art results in both dependency and discourse parsing tasks with the same computational efficiency (Ma et al., 2018;Lin et al., 2019); thanks to the encoder-decoder architecture that makes it possible to capture information from the whole text and the previously derived subtrees, while limiting the number of parsing steps to linear.

the decoder of these parsers has a sequential structure, which may not yield the most appropriate inductive bias for deriving a hierarchical structure.


Thus it contains information about its children.

in our model we consider the decoder state when the sibling was first generated from its parent.


Recent sequence labeling models achieve state-of-the-art performance by combining both character-level and word-level information (Chiu and Nichols, 2016;Ma and Hovy, 2016;Lample et al., 2016).

these models heavily rely on large-scale annotated training data, which may not be available in most languages.


It is worth mentioning that, in previous work and this work, the corpora used in the experiments are limited to the source and the target language.

the multilingual BERT is jointly learned on Wikipedia of 102 languages and may benefit from a multi-hop transfer.


Wikipedia contains multilingual articles for various topics and can thus be used to generate parallel/comparable corpora or even weakly annotated target language sentences (Kim et al., 2012).

parallel corpora and Wikipedia can be rare for true low-resource languages.


Some of the previous work also proposes sequence labeling models with shared parameters between languages for performing cross-lingual knowledge transfer (Lin et al., 2018;Cotterell and Duh, 2017;Yang et al., 2017;Ammar et al., 2016;Kim et al., 2017).

these models are usually obtained through joint learning and require annotated data from the target language.


Recurrent neural networks (RNN) used for Chinese named entity recognition (NER) that sequentially track character and word information have achieved great success.

the characteristic of chain structure and the lack of global semantics determine that RNN-based models are vulnerable to word ambiguities.


and then apply word sequence labeling (Yang et al., 2016;He and Sun, 2017).

the rare gold-standard segmentation in NER datasets and incorrectly segmented entity boundaries both negatively impact the identification of named entities (Peng and Dredze, 2015;He and Sun, 2016).


In particular, Zhang and Yang (2018) introduced a variant of a long short-term memory network (latticestructured LSTM) that encodes all potential words matching a sentence to exploit explicit word information, achieving state-of-the-art results.

these methods are usually based on RNN or CRF to sequentially encode a sentence, while the underlying structure of language is not strictly sequential (Shen et al., 2019).


Especially, Zhang and Yang (2018) proposed a lattice LSTM to model characters and potential words simultaneously.

their lattice LSTM used a concatenation of independently trained left-toright and right-to-left LSTM to represent features, which was also limited (Devlin et al., 2018).


The F1 score of LGN decreases by 3.59% on average on the four datasets without CRF.


However, the lattice accuracy decreases significantly as the sentence length increases.

the LGN not only gives higher results over short sentences, but also shows its effectiveness and robustness when the sentence length is more than 80 characters.


graph composition states are updated for only one step.

it gives an incorrect class of the entity "印度河(The Indus River)", which is a location entity but not a GPE (Geo-Political Entity).


Moreover, the capsule network with dynamic routing algorithms (Zhang et al., 2018a) is proposed to perform interactions in both directions.

there are still two limitations in this model.


Considering the requirement of the annotated parse trees and the costly annotation effort, most prior work relied on the supervised syntactic parser.

a supervised parser may be unavailable when the language is low-resourced or the target data has different distribution from the source domain.


By top-down greedy parsing (Shen et al., 2018a), which recursively splits the sentence into two constituents with minimum a, a parse tree can be formed.

because each layer has a set of a l , we have to decide to use which layer for parsing.


It is worth mentioning that we have tried to initialize our Transformer model with pre-trained BERT, and then fine-tuning on WSJ-train.

in this setting, even when the training loss becomes lower than the loss of training from scratch, the parsing result is still far from our best results.


The basic factorized model got it wrong, assigning A1 to the argument 'state'.

taking into account other arguments, the model can correct the label.


Probabilistic methods for aggregating crowdsourced data have been shown to be more accurate than simple heuristics such as majority vot-ing (Raykar et al., 2010;Sheshadri and Lease, 2013;Rodrigues et al., 2013;Hovy et al., 2013).

existing methods for aggregating sequence labels cannot model dependencies between the annotators' labels (Rodrigues et al., 2014;Nguyen et al., 2017) and hence do not account for their effect on annotator noise and bias.


Like spam, CM can model spammers who frequently chose one label regardless of the ground truth, but also models different error rates and biases for each class.

cM ignores dependencies between annotations in a sequence, such as the fact that an 'I' cannot immediately follow an 'O'.


The choice of annotator model for a particular annotator depends on the developer's understanding of the annotation task: if the annotations have sequential dependencies, this suggests the seq model; for non-sequential classifications CM may be effective with small (≤ 5) numbers of classes; spam may be more suitable if there are many classes, as the number of parameters to learn is low.

there is also a trade-off between the expressiveness of the model and the number of parameters that must be learned.


This is a strong assumption when considering that the annotators have to make their decisions based on the same input data.

in practice, dependencies do not usually cause the most probable label to change (Zhang, 2004), hence the performance of classifier combination methods is only slightly degraded, while avoiding the complexity of modelling dependencies between annotators (Kim and Ghahramani, 2012).


In this way, an efficient inference algorithm such as maximum directed spanning tree algorithm (Chu and Liu, 1965) can be used.

with the corpus-wise constraints, directly solving Eq.


Computing devices have recently become capable of interacting with their end users via natural language.

they can only operate within a limited "supported" domain of discourse and fail drastically when faced with an out-of-domain utterance, mainly due to the limitations of their semantic parser.


Current commercial conversational agents such as Siri, Alexa or Google Assistant come with a fixed set of simple functions like setting alarms and making reminders, but are often not able to cater to the specific phrasing of a user or the specific action a ⇤ These two authors contributed equally user needs.

it has recently been shown that it is possible to add new functionalities to an agent through natural language instruction (Azaria et al., 2016;Labutov et al., 2018).


On one hand, this suggests that the discriminator has room for improvement.

the numbers suggest that there is still a much larger room for improvement for the encoder, aligner, and look-up components.


Grammar-based parsers work by having a set of grammar rules that are either learned or hand-written, an algorithm for generating a set of candidate logical forms by recursive application of the grammar rules, and a criterion for picking the best candidate logical form within that set (Liang and Potts, 2015;Collins, 2005, 2007).

they are brittle to the flexibility of language.


As speech recognition technologies mature, more computing devices support spoken instructions via a conversational agent.

most agents do not adapt to the phrasing and interest of a specific end user.


In this context, various approaches based on modifying the RNN or LSTM architecture have been proposed to speed up the process (Seo et al., 2018;Yu et al., 2017).

the processing in these models is still fundamentally sequential and needs to operate on the whole document which limits the computational gain.


However, the processing in these models is still fundamentally sequential and needs to operate on the whole document which limits the computational gain.

to previous approaches, we propose a novel framework for efficient text classification on long documents that mitigates sequential processing.


That is our approach achieves higher performance across different test-time budgets and its performance is a predictable monotonic function of the test-time budget.

the performance of skim-RNN exhibits inconsistency for different budgets.


These works use relations from ConceptNet, a crowd-sourced database of structured commonsense knowledge, to train and validate their models (Liu and Singh, 2004).

it has been shown that these methods generalize poorly to novel data (Li et al., 2016;Jastrzebski et al., 2018).


Especially for harder analogies, where interclass similarity is high and intraclass similarities are low (e.g., in GN/BATS), DensRay outperforms SVMs.

to SVMs, DensRay considers difference vectors within classes as wellthis seems to be of advantage here.


Meta-learning algorithms have received lots of attention recently due to their effectiveness (Finn et al., 2017;Fan et al., 2018).

the potential of applying meta-learning algorithms in NLU tasks have not been fully investigated yet.


Syntactic structures interact closely with semantics in learning compositional representations and alleviating long-range dependency issues.

such structure priors have not been well exploited in previous work for semantic modeling.


The table shows that embedding similarity correlates better or the same as ROUGE with human ratings on informativeness, relevance and surrogate.

rOUGE precision is a more suitable metric for evaluating the extent of unnecessary content and verbosity.


The incorporation of pseudo data in the training of grammatical error correction models has been one of the main factors in improving the performance of such models.

consensus is lacking on experimental configurations, namely, choosing how the pseudo data should be generated or used.


For example, the encoder-decoder (EncDec) model (Sutskever et al., 2014;Bahdanau et al., 2015), which was originally proposed for MT, has been applied widely to GEC and has achieved remarkable results in the GEC research field (Ji et al., 2017;Chollampatt and Ng, 2018;.

a challenge in applying EncDec to GEC is that EncDec requires a large amount of training data (Koehn and Knowles, 2017), but the largest set of publicly available parallel data (Lang-8) in GEC has only two million sentence pairs (Mizumoto et al., 2011).


* Current affiliation: Future Corporation When incorporating pseudo data, several decisions must be made about the experimental configurations, namely, (i) the method of generating the pseudo data, (ii) the seed corpus for the pseudo data, and (iii) the optimization setting (Section 2).

consensus on these decisions in the GEC research field is yet to be formulated.


On one hand, the response must contain the desired information, referred to as meaning representation (MR), in order to provide or request a user's information.

the system response needs to mimic the fluency and variation in human language to improve the user experience.


However, it still remains a challenge in task-oriented dialogue systems to generate truly natural utterance indistinguishable from a human's response.

language modeling is a technique typically employed to learn language patterns from text.


However, it suffers from several drawbacks: First, in order to maintain the SLU performance on both original and new expressions, it usually requires almost retraining the model using the whole dataset.

as the size of training set grows, it becomes infeasible to repeatedly conduct time consuming retraining on such a large dataset.


Since FT-AttRNN is only trained on new data, it is oftentimes overwhelmed by new knowledge and results in forgetting the old knowledge.

fT-Lr-AttRNN has difficulty to learn new knowledge since it cannot jump out of local optimum due to a small learning rate.


Such NLU systems cater to utterances in isolation, thus pushing the problem of context management to DM.

contextual information is critical to the correct prediction of intents and slots in a conversation.


(2015) proposed adding contextual signals to the joint IC-SL task.

the contributions of their work were limited in terms of number of signals and how they were used, rendering the contextualization process still less interpretable.


For the former, we simply concatenate the contextual signals to get current turn feature vector, i.e.

for the latter, concatenation becomes intractable if context window is large.


The main approach of previous work (Upadhyay et al., 2018;Chen et al., 2018;Schuster et al., 2019) in this task is using aligned cross-lingual word embeddings between source and target languages.

this method suffers from imperfect alignments between the source and target language embeddings.


Correctly identifying out-of-scope cases is thus crucial in deployed systems-both to avoid performing the wrong action and also to identify potential future directions for development.

this problem has seen little attention in analyses and evaluations of intent classification systems.


Similar experiments were conducted for evaluating unknown intent discovery models in Lin and Xu (2019).

our out-of-scope queries cover a broad range of phenomena and are similar in style and often similar in topic to in-scope queries, representing things a user might say given partial knowledge of the capabilities of a system.


First of all, the Alloperations model is forced to use an operation (in this case Random Swap) with a fixed number of changes and a probability of 1.0, leading to less variation in the source inputs.

our Input-agnostic AutoAugment model samples 3 Verb Dropout's followed by Random Swap.


This suggests that using MWT for distant languages may help.

for close languages pairs the best way is still to translate directly (BI), as can be seen for Spanish and Portuguese.


Alignment errors have been noted to have a small effect on statistical MT performance (Goutte et al., 2012).

misaligned sentences have been shown to be much more detrimental to neural MT (NMT) (Khayrallah and Koehn, 2018).


Simultaneous translation outputs target words while the source sentence is being received, and is widely useful in international conferences, negotiations and press releases.

although there is significant progress in machine translation (MT) recently, simultaneous machine translation is still one of the most challenging tasks.


Thus, such a sequence must have | | number of WRITE actions.

not every action sequence is good for simultaneous translation.


To apply the learned policy for simultaneous translation, we can choose at each step the action with higher probability .

different scenarios may have different latency requirements.


It is possible that each hidden state in the decoder takes the previous hidden state into consideration, which would be somewhat similar to the proposed RPEs.

the encoder would not be expected to contain this mechanism.


Translating into one of these high-resource languages gives the possibility to address the downstream task by: i) using existing tools for that language to process the translated text, and ii) projecting their output back to the original language.

using MT "as is" might not be optimal for different reasons.


It is common practice in modern NLP to represent text in a continuous space.

the interface between the discrete world of language and the continuous representation persists and is arguably nowhere so important as in deciding what should be the atomic symbols that will be used as input and/or output.


Neural machine translation (NMT) is the current state-of-the-art.

with statistical machine translation (SMT; Koehn et al., 2007), where there are several established methods of incorporating external knowledge, 1 recent work is still examining how best to incorporate bilingual lexicons into NMT systems.


Semi-supervised approaches for NMT are often based on automatically creating pseudoparallel sentences through methods such as backtranslation (Irvine and Callison-Burch, 2013;Sennrich et al., 2016) or adding an auxiliary autoencoding task on monolingual data (Cheng et al., 2016;Currey et al., 2017).

both methods have problems with lowresource and syntactically divergent language pairs.


tactic analysis tools, a linguist with rudimentary knowledge of the structure of the target language can create them in short order using these tools.

similar pre-ordering methods have not proven useful in NMT (Du and Way, 2017), largely because high-resource scenarios NMT is much more effective at learning reordering than previous SMT methods were (Bentivogli et al., 2016).


For example, the "test-time waitk" scheme  uses the full-sentence translation model and performs wait-k decoding at test time.

the obvious training-testing mismatch in this scheme usually leads to inferior quality.


Therefore, absolute position (Vaswani et al., 2017) or relative position (Shaw et al., 2018) are generally used to capture the sequential order of words in the sentence.

several researches reveal that the sequential structure may not be sufficient for NLP tasks (Tai et al., 2015;Kim et al., 2017;Shen et al., 2019), since sentences inherently have hierarchical structures (Chomsky, 1965;Bever, 1970).


This is because vocabularies for models #2 to #4 involve the target side of the En-XX corpus and "one" non-English corpus from the multi-parallel corpus.

the vocabularies for models #5 to #7 involve the target sides of the En-XX corpus and "all" non-English corpora from the multi-parallel corpus.


Simple fine-tuning (#2 and #5) gave great improvements over the baseline.

#5 was worse than #2, despite being trained in the same way, because #5 involves up to eight target languages, inevitably reducing the allowance for each target language.


However, #5 was worse than #2, despite being trained in the same way, because #5 involves up to eight target languages, inevitably reducing the allowance for each target language.

exploiting the multiparallel corpus through mixed pre-training (#6) or mixed fine-tuning (#7) brought consistent improvements over the corresponding 1-to-2 models (#3 and #4).


Previous unsupervised domain adaptation strategies include training the model with in-domain copied monolingual or back-translated data.

these methods use generic representations for text regardless of domain shift, which makes it infeasible for translation models to control outputs conditional on a specific domain.


(2016a) concatenate backtranslated data with the original corpus.

these methods learn generic representations for all the text, as the learned representations are shared for all the domains and synthetic and natural data are treated equally.


We characterize the two baselines as data-centric methods as they rely on synthesized data.

our approach is model-centric as we mainly focus on modifying the model architecture.


There are also work on adaptation via retrieving sentences or n-grams in the training data similar to the test set (Farajian et al., 2017;Bapna and Firat, 2019).

it can be difficult to find similar parallel sentences in domain adaptation settings.


Neural machine translation (NMT) has achieved new state-of-the-art performance in translating ambiguous words.

it is still unclear which component dominates the process of disambiguation.


We find that encoder hidden states outperform word embeddings significantly which indicates that encoders adequately encode relevant information for disambiguation into hidden states.

to encoders, the effect of decoder is different in models with different architectures.


The WSD accuracy of using bidirectional hidden states are competitive to using hidden states from Transformer models.

concatenating forward and backward hidden states doubles the dimension.


Thus, a pipeline model of the tasks has been adopted widely by previous studies.

the model has a problem that it cannot utilize interactions among the tasks.


decompose and recover morphemes from eojeols or assign so-called POSMORPH tags (Heigold et al., 2016), and then an actual POS tag sequence is determined or resolved from the POSMORPH tags using a sequential labeling algorithm.

this pipeline model suffers from two kinds of weaknesses.


This is the information flow on which the previous studies focus.

the eojeol '나는' which appears twice in this figure is morphologically ambiguous and thus can be analyzed in two ways.


In POS tagging represented by dotted arrows in Figure 2, it is possible to generate a POS tag at every time t by paying attention to the encoder syllable states as done in morpheme processing.

this approach does not reflect the global dependency among adjacent tags.


Generally speaking, LSTM has shown great success for sequential data, leveraging long range dependencies and preserving the temporal order of the sequence (Cho et al., 2014;Graves, 2013).

lSTM requires intensive computational resources both for training and inference due to its sequential nature.


Feature engineering and classical machine learning algorithms such as Hidden Markov Models, Maximum Entropy Models, and Finite State Transducer were the dominant approaches (Nelken and Shieber, 2005;Zitouni et al., 2006;Elshafei et al., 2006).

recent studies show significant improvement using deep neural networks (Belinkov and Glass, 2015;Pham et al., 2017;Orife, 2018).


Prior work on training generative Visual Dialog models with reinforcement learning (Das et al., 2017b) has explored a Q-BOT-A-BOT image-guessing game and shown that this 'self-talk' approach can lead to improved performance at the downstream dialogconditioned image-guessing task.

this improvement saturates and starts degrading after a few rounds of interaction, and does not lead to a better Visual Dialog model.


A typical cross-lingual transfer learning approach boosting model performance on a resource-poor language is to pre-train the model on all available supervised data from another resource-rich language.

in large-scale systems, this leads to high training times and computational requirements.


A typical approach is to pre-train the model on labeled data from a richly resourced language, and then either apply it directly on a target language (Upadhyay et al., 2018) or finetune it on a smaller amount of supervised data from a target language (Do and Gaspers, 2019).

both in SLU and other NLP tasks, prior work on CLTL typically utilized all available source data to transfer knowledge, as it has been mainly inves-tigated in rather small Academic settings.


Instead of selecting the top K% utterances, we define a threshold θ: u is selected if R(u) >= θ. θ and α k become hyperparameters which can be optimized using Bayesian Optimization with the score of the CLTL model on a development set as the objective.

while this could improve performance, it is expensive, especially in large-scale settings, i.e.


The inference time complexity is O(M N ) (for generating M query representations for a size N datatset).

to the prior works, we leverage intra-modal multi-head attention, which can be easily parallelized compared to DAN and is with a preferred O(M ) inference time complexity compared to SCAN.


One of the desired properties of multi-head attention is its ability to jointly attend to and encode different information in the embedding space.

there is no mechanism to support that these attention heads indeed capture diverse information.


Object detection plays an important role in current solutions to vision and language tasks like image captioning and visual question answering.

popular models like Faster R-CNN rely on a costly process of annotating ground-truths for both the bounding boxes and their corresponding semantic labels, making it less amenable as a primitive task for transfer learning.


Prior work demonstrated the power of pre-training with image classification at scale (Sun et al., 2017;Mahajan et al., 2018;Wu et al., 2019).

we consider downstream vision and language tasks (image captioning and visual question answering), in contrast to less complex vision-only tasks explored in such work: object detection and in some cases semantic segmentation and human pose estimation.


Recent work focuses on learning the mapping from visual segments to the input text (Hendricks et al., 2017;Gao et al., 2017a;Liu et al., 2018;Hendricks et al., 2018;Zhang et al., 2018) and retrieving segments based on the alignment scores.

in order to successfully train a NLL model, a large number of diverse language descriptions are needed to describe different temporal segments of videos which incurs high human labeling cost.


3 Specific Settings Our model generalizes WM18, which can be realized by setting M = I 3 and β = m. Another interesting instance of the model is obtained by setting M = (1 − α m )I 3 and β = α m m, which we call the Diagonal Covariance (DC) model.

to the RGB model and WM18, which model m as a function of r and m, m in the DC model does not depend on r. Given r and m, to predict the t, our DC model predicts m first and then applies a linear transformation to get the target color vector as follows: is a scalar which only depends on m and measures the distance from r to m. In the DC model m is the interpolation point for modifiers, such as 0 0 0 for the modifier "darker".


Though TF enables efficient training, it results in "exposure bias" because agents must follow learned rather than gold trajectories at test time.

(ii) Student-forcing (SF), where an action a S is drawn from the current learned policy, allows the agent to learn from its own actions (aligning training and evaluation), however, it is inefficient, as the agent explores randomly when confused or in the early stages of training.


Previous studies (Barrett and Søgaard, 2015b;Barrett et al., 2016) suggest that real-time eye-tracking data can be collected at inference time, so that token-level gaze features are used during training but also at test time.

even if in the near future every user has an eye tracker on top of their screen -a scenario which is far from guaranteed, and raises privacy concerns (Liebling and Preibusch, 2014)many running NLP applications that process data from various Internet sources will not expect to have any human being reading massive amounts of data.


When looking at the dev set scores, the most discriminative gaze feature is mean fix dur that increases LAS by +0.17 and first fix dur by +0.14.

evaluation on the test set shows that the most informative gaze features are from the context group learned as multiple auxiliary tasks (context feats aux) and they improve the LAS score by +0.18, followed by fix prob and w−1 fix prob with +0.13, total fix dur with +0.12 and late feats aux with +0.10.


We considered using the constituency parsed Switchboard corpus (Godfrey et al., 1992), which is a human-human telephone corpus, due to its similarity to our domain.

no fully UDcompliant version of the dependency parsed corpus is publicly available.


These results indicate that our fine-tuned model is more closely aligned to the speech domain than our baseline model.

our best model still struggles when faced with fixed expressions common in conversational speech, such as "Top Gun" and "Kitchen Table Wisdom".


The widely used method for document-level translation usually compresses the context information into a representation via hierarchical attention networks.

this method neither considers the relationship between context words nor distinguishes the roles of context words.