ConvAI baseline solution
Machine comprehension (MC), answering a query about a given context paragraph, requires modeling complex interactions between the context and the query. Recently, attention mechanisms have been successfully extended to MC. Typically these methods use attention to focus on a small portion of the context and summarize it with a fixed-size vector, couple attentions temporally, and/or often form a uni-directional attention. In this paper we introduce the Bi-Directional Attention Flow (BIDAF) network, a multi-stage hierarchical process that represents the context at different levels of granularity and uses bi-directional attention flow mechanism to obtain a query-aware context representation without early summarization. Our experimental evaluations show that our model achieves the state-of-the-art results in Stanford Question Answering Dataset (SQuAD) and CNN/DailyMail cloze test.READ FULL TEXT VIEW PDF
Machine comprehension is a representative task of natural language
In this paper, we introduce the Reinforced Mnemonic Reader for machine
To answer the question in machine comprehension (MC) task, the models ne...
Previous machine comprehension (MC) datasets are either too small to tra...
Machine comprehension(MC) style question answering is a representative
Multi-hop reasoning question answering requires deep comprehension of
We introduce a relational graph neural network with bi-directional atten...
ConvAI baseline solution
Bidirectional Attention Flow for Machine Comprehension, Minjoon Seo, Aniruddha Kembhavi, Ali Farhadi, Hannaneh Hajishirzi https://arxiv.org/abs/1611.01603
With reference to this paper - https://arxiv.org/pdf/1611.01603.pdf
The tasks of machine comprehension (MC) and question answering (QA) have gained significant popularity over the past few years within the natural language processing and computer vision communities. Systems trained end-to-end now achieve promising results on a variety of tasks in the text and image domains. One of the key factors to the advancement has been the use of neural attention mechanism, which enables the system to focus on a targeted area within a context paragraph (for MC) or within an image (for Visual QA), that is most relevant to answer the question(Weston et al., 2015; Antol et al., 2015; Xiong et al., 2016a). Attention mechanisms in previous works typically have one or more of the following characteristics. First, the computed attention weights are often used to extract the most relevant information from the context for answering the question by summarizing the context into a fixed-size vector. Second, in the text domain, they are often temporally dynamic, whereby the attention weights at the current time step are a function of the attended vector at the previous time step. Third, they are usually uni-directional, wherein the query attends on the context paragraph or the image.
In this paper, we introduce the Bi-Directional Attention Flow (BiDAF) network, a hierarchical multi-stage architecture for modeling the representations of the context paragraph at different levels of granularity (Figure 1). BiDAF includes character-level, word-level, and contextual embeddings, and uses bi-directional attention flow to obtain a query-aware context representation. Our attention mechanism offers following improvements to the previously popular attention paradigms. First, our attention layer is not used to summarize the context paragraph into a fixed-size vector. Instead, the attention is computed for every time step, and the attended vector at each time step, along with the representations from previous layers, is allowed to flow through to the subsequent modeling layer. This reduces the information loss caused by early summarization. Second, we use a memory-less attention mechanism. That is, while we iteratively compute attention through time as in Bahdanau et al. (2015), the attention at each time step is a function of only the query and the context paragraph at the current time step and does not directly depend on the attention at the previous time step. We hypothesize that this simplification leads to the division of labor between the attention layer and the modeling layer. It forces the attention layer to focus on learning the attention between the query and the context, and enables the modeling layer to focus on learning the interaction within the query-aware context representation (the output of the attention layer). It also allows the attention at each time step to be unaffected from incorrect attendances at previous time steps. Our experiments show that memory-less attention gives a clear advantage over dynamic attention. Third, we use attention mechanisms in both directions, query-to-context and context-to-query, which provide complimentary information to each other.
Our BiDAF model111Our code and interactive demo are available at: allenai.github.io/bi-att-flow/ outperforms all previous approaches on the highly-competitive Stanford Question Answering Dataset (SQuAD) test set leaderboard at the time of submission. With a modification to only the output layer, BiDAF achieves the state-of-the-art results on the CNN/DailyMail cloze test. We also provide an in-depth ablation study of our model on the SQuAD development set, visualize the intermediate feature spaces in our model, and analyse its performance as compared to a more traditional language model for machine comprehension (Rajpurkar et al., 2016).
Our machine comprehension model is a hierarchical multi-stage process and consists of six layers (Figure 1):
Character Embedding Layer maps each word to a vector space using character-level CNNs.
Word Embedding Layer maps each word to a vector space using a pre-trained word embedding model.
Contextual Embedding Layer utilizes contextual cues from surrounding words to refine the embedding of the words. These first three layers are applied to both the query and context.
Attention Flow Layer couples the query and context vectors and produces a set of query-aware feature vectors for each word in the context.
employs a Recurrent Neural Network to scan the context.
Output Layer provides an answer to the query.
Character embedding layer is responsible for mapping each word to a high-dimensional vector space. Let and represent the words in the input context paragraph and query, respectively. Following Kim (2014)
, we obtain the character-level embedding of each word using Convolutional Neural Networks (CNN). Characters are embedded into vectors, which can be considered as 1D inputs to the CNN, and whose size is the input channel size of the CNN. The outputs of the CNN are max-pooled over the entire width to obtain a fixed-size vector for each word.
Word embedding layer also maps each word to a high-dimensional vector space. We use pre-trained word vectors, GloVe (Pennington et al., 2014), to obtain the fixed word embedding of each word.
The concatenation of the character and word embedding vectors is passed to a two-layer Highway Network (Srivastava et al., 2015). The outputs of the Highway Network are two sequences of -dimensional vectors, or more conveniently, two matrices: for the context and for the query.
We use a Long Short-Term Memory Network (LSTM)(Hochreiter & Schmidhuber, 1997) on top of the embeddings provided by the previous layers to model the temporal interactions between words. We place an LSTM in both directions, and concatenate the outputs of the two LSTMs. Hence we obtain from the context word vectors , and from query word vectors . Note that each column vector of and is -dimensional because of the concatenation of the outputs of the forward and backward LSTMs, each with -dimensional output.
It is worth noting that the first three layers of the model are computing features from the query and context at different levels of granularity, akin to the multi-stage feature computation of convolutional neural networks in the computer vision field.
Attention flow layer is responsible for linking and fusing information from the context and the query words. Unlike previously popular attention mechanisms (Weston et al., 2015; Hill et al., 2016; Sordoni et al., 2016; Shen et al., 2016), the attention flow layer is not used to summarize the query and context into single feature vectors. Instead, the attention vector at each time step, along with the embeddings from previous layers, are allowed to flow through to the subsequent modeling layer. This reduces the information loss caused by early summarization.
The inputs to the layer are contextual vector representations of the context and the query . The outputs of the layer are the query-aware vector representations of the context words, , along with the contextual embeddings from the previous layer.
In this layer, we compute attentions in two directions: from context to query as well as from query to context. Both of these attentions, which will be discussed below, are derived from a shared similarity matrix, , between the contextual embeddings of the context () and the query (), where indicates the similarity between -th context word and -th query word. The similarity matrix is computed by
where is a trainable scalar function that encodes the similarity between its two input vectors, is -th column vector of , and is -th column vector of , We choose , where is a trainable weight vector, is elementwise multiplication, is vector concatenation across row, and implicit multiplication is matrix multiplication. Now we use to obtain the attentions and the attended vectors in both directions.
Context-to-query Attention. Context-to-query (C2Q) attention signifies which query words are most relevant to each context word. Let represent the attention weights on the query words by -th context word, for all . The attention weight is computed by , and subsequently each attended query vector is . Hence is a -by- matrix containing the attended query vectors for the entire context.
Query-to-context Attention. Query-to-context (Q2C) attention signifies which context words have the closest similarity to one of the query words and are hence critical for answering the query. We obtain the attention weights on the context words by , where the maximum function () is performed across the column. Then the attended context vector is . This vector indicates the weighted sum of the most important words in the context with respect to the query. is tiled times across the column, thus giving .
Finally, the contextual embeddings and the attention vectors are combined together to yield , where each column vector can be considered as the query-aware representation of each context word. We define by
where is the -th column vector (corresponding to -th context word), is a trainable vector function that fuses its (three) input vectors, and is the output dimension of the function. While the
function can be an arbitrary trainable neural network, such as multi-layer perceptron, a simple concatenation as following still shows good performance in our experiments:(i.e., ).
The input to the modeling layer is , which encodes the query-aware representations of context words. The output of the modeling layer captures the interaction among the context words conditioned on the query. This is different from the contextual embedding layer, which captures the interaction among context words independent of the query. We use two layers of bi-directional LSTM, with the output size of for each direction. Hence we obtain a matrix , which is passed onto the output layer to predict the answer. Each column vector of is expected to contain contextual information about the word with respect to the entire context paragraph and the query.
The output layer is application-specific. The modular nature of BiDAF allows us to easily swap out the output layer based on the task, with the rest of the architecture remaining exactly the same. Here, we describe the output layer for the QA task. In section 5, we use a slight modification of this output layer for cloze-style comprehension.
The QA task requires the model to find a sub-phrase of the paragraph to answer the query. The phrase is derived by predicting the start and the end indices of the phrase in the paragraph. We obtain the probability distribution of the start index over the entire paragraph by
where is a trainable weight vector. For the end index of the answer phrase, we pass to another bidirectional LSTM layer and obtain . Then we use to obtain the probability distribution of the end index in a similar manner:
Training. We define the training loss (to be minimized) as the sum of the negative log probabilities of the true start and end indices by the predicted distributions, averaged over all examples:
where is the set of all trainable weights in the model (the weights and biases of CNN filters and LSTM cells, , and ), is the number of examples in the dataset, and are the true start and end indices of the -th example, respectively, and indicates the -th value of the vector .
Test. The answer span where with the maximum value of is chosen, which can be computed in linear time with dynamic programming.
A significant contributor to the advancement of MC models has been the availability of large datasets. Early datasets such as MCTest (Richardson et al., 2013) were too small to train end-to-end neural models. Massive cloze test datasets (CNN/DailyMail by Hermann et al. (2015) and Childrens Book Test by Hill et al. (2016)), enabled the application of deep neural architectures to this task. More recently, Rajpurkar et al. (2016) released the Stanford Question Answering (SQuAD) dataset with over 100,000 questions. We evaluate the performance of our comprehension system on both SQuAD and CNN/DailyMail datasets.
Previous works in end-to-end machine comprehension use attention mechanisms in three distinct ways. The first group (largely inspired by Bahdanau et al. (2015)) uses a dynamic attention mechanism, in which the attention weights are updated dynamically given the query and the context as well as the previous attention. Hermann et al. (2015)
argue that the dynamic attention model performs better than using a single fixed query vector to attend on context words on CNN & DailyMail datasets.Chen et al. (2016) show that simply using bilinear term for computing the attention weights in the same model drastically improves the accuracy. Wang & Jiang (2016) reverse the direction of the attention (attending on query words as the context RNN progresses) for SQuAD. In contrast to these models, BiDAF uses a memory-less attention mechanism.
The second group computes the attention weights once, which are then fed into an output layer for final prediction (e.g., Kadlec et al. (2016)). Attention-over-attention model (Cui et al., 2016) uses a 2D similarity matrix between the query and context words (similar to Equation 1) to compute the weighted average of query-to-context attention. In contrast to these models, BiDAF does not summarize the two modalities in the attention layer and instead lets the attention vectors flow into the modeling (RNN) layer.
The third group (considered as variants of Memory Network (Weston et al., 2015)) repeats computing an attention vector between the query and the context through multiple layers, typically referred to as multi-hop (Sordoni et al., 2016; Dhingra et al., 2016). Shen et al. (2016)
combine Memory Networks with Reinforcement Learning in order to dynamically control the number of hops. One can also extend ourBiDAF model to incorporate multiple hops.
The task of question answering has also gained a lot of interest in the computer vision community. Early works on visual question answering (VQA) involved encoding the question using an RNN, encoding the image using a CNN and combining them to answer the question (Antol et al., 2015; Malinowski et al., 2015). Attention mechanisms have also been successfully employed for the VQA task and can be broadly clustered based on the granularity of their attention and the approach to construct the attention matrix. At the coarse level of granularity, the question attends to different patches in the image (Zhu et al., 2016; Xiong et al., 2016a). At a finer level, each question word attends to each image patch and the highest attention value for each spatial location (Xu & Saenko, 2016) is adopted. A hybrid approach is to combine questions representations at multiple levels of granularity (unigrams, bigrams, trigrams) (Yang et al., 2015). Several approaches to constructing the attention matrix have been used including element-wise product, element-wise sum, concatenation and Multimodal Compact Bilinear Pooling (Fukui et al., 2016).
Lu et al. (2016) have recently shown that in addition to attending from the question to image patches, attending from the image back to the question words provides an improvement on the VQA task. This finding in the visual domain is consistent with our finding in the language domain, where our bi-directional attention between the query and context provides improved results. Their model, however, uses the attention weights directly in the output layer and does not take advantage of the attention flow to the modeling layer.
In this section, we evaluate our model on the task of question answering using the recently released SQuAD (Rajpurkar et al., 2016), which has gained a huge attention over a few months. In the next section, we evaluate our model on the task of cloze-style reading comprehension.
SQuAD is a machine comprehension dataset on a large set of Wikipedia articles, with more than 100,000 questions. The answer to each question is always a span in the context. The model is given a credit if its answer matches one of the human written answers. Two metrics are used to evaluate models: Exact Match (EM) and a softer metric, F1 score, which measures the weighted average of the precision and recall rate at character level. The dataset consists of 90k/10k train/dev question-context tuples with a large hidden test set. It is one of the largest available MC datasets with human-written questions and serves as a great test bed for our model.
The model architecture used for this task is depicted in Figure 1. Each paragraph and question are tokenized by a regular-expression-based word tokenizer (PTB Tokenizer) and fed into the model. We use 100 1D filters for CNN char embedding, each with a width of 5. The hidden state size () of the model is 100. The model has about 2.6 million parameters. We use the AdaDelta (Zeiler, 2012) optimizer, with a minibatch size of 60 and an initial learning rate of
, for 12 epochs. A dropout(Srivastava et al., 2014) rate of
is used for the CNN, all LSTM layers, and the linear transformation before the softmax for the answers. During training, the moving averages of all weights of the model are maintained with the exponential decay rate of. At test time, the moving averages instead of the raw weights are used. The training process takes roughly 20 hours on a single Titan X GPU. We also train an ensemble model consisting of 12 training runs with the identical architecture and hyper-parameters. At test time, we choose the answer with the highest sum of confidence scores amongst the 12 runs for each question.
The results of our model and competing approaches on the hidden test are summarized in Table 1(a). BiDAF (ensemble) achieves an EM score of 73.3 and an F1 score of 81.1, outperforming all previous approaches.
Table 1(b) shows the performance of our model and its ablations on the SQuAD dev set. Both char-level and word-level embeddings contribute towards the model’s performance. We conjecture that word-level embedding is better at representing the semantics of each word as a whole, while char-level embedding can better handle out-of-vocab (OOV) or rare words. To evaluate bi-directional attention, we remove C2Q and Q2C attentions. For ablating C2Q attention, we replace the attended question vector with the average of the output vectors of the question’s contextual embedding layer (LSTM). C2Q attention proves to be critical with a drop of more than 10 points on both metrics. For ablating Q2C attention, the output of the attention layer, , does not include terms that have the attended Q2C vectors, . To evaluate the attention flow, we study a dynamic attention model, where the attention is dynamically computed within the modeling layer’s LSTM, following previous work (Bahdanau et al., 2015; Wang & Jiang, 2016). This is in contrast with our approach, where the attention is pre-computed before flowing to the modeling layer. Despite being a simpler attention mechanism, our proposed static attention outperforms the dynamically computed attention by more than 3 points. We conjecture that separating out the attention layer results in a richer set of features computed in the first 4 layers which are then incorporated by the modeling layer. We also show the performance of BiDAF with several different definitions of and functions (Equation 1 and 2) in Appendix B.
We now provide a qualitative analysis of our model on the SQuAD dev set. First, we visualize the feature spaces after the word and contextual embedding layers. These two layers are responsible for aligning the embeddings between the query and context words which are the inputs to the subsequent attention layer. To visualize the embeddings, we choose a few frequent query words in the dev data and look at the context words that have the highest cosine similarity to the query words (Table2). At the word embedding layer, query words such as When, Where and Who are not well aligned to possible answers in the context, but this dramatically changes in the contextual embedding layer which has access to context from surrounding words and is just 1 layer below the attention layer. When begins to match years, Where matches locations, and Who matches names.
|Layer||Query||Closest words in the Context using cosine similarity|
|Word||When||when, When, After, after, He, he, But, but, before, Before|
|Contextual||When||When, when, 1945, 1991, 1971, 1967, 1990, 1972, 1965, 1953|
|Word||Where||Where, where, It, IT, it, they, They, that, That, city|
|Contextual||Where||where, Where, Rotterdam, area, Nearby, location, outside, Area, across, locations|
|Word||Who||Who, who, He, he, had, have, she, She, They, they|
|Contextual||Who||who, whose, whom, Guiscard, person, John, Thomas, families, Elway, Louis|
|Word||city||City, city, town, Town, Capital, capital, district, cities, province, Downtown|
|Contextual||city||city, City, Angeles, Paris, Prague, Chicago, Port, Pittsburgh, London, Manhattan|
|Word||January||July, December, June, October, January, September, February, April, November, March|
|Contextual||January||January, March, December, August, December, July, July, July, March, December|
|Word||Seahawks||Seahawks, Broncos, 49ers, Ravens, Chargers, Steelers, quarterback, Vikings, Colts, NFL|
|Contextual||Seahawks||Seahawks, Broncos, Panthers, Vikings, Packers, Ravens, Patriots, Falcons, Steelers, Chargers|
|Word||date||date, dates, until, Until, June, July, Year, year, December, deadline|
|Contextual||date||date, dates, December, July, January, October, June, November, March, February|
We also visualize these two feature spaces using t-SNE in Figure 2. t-SNE is performed on a large fraction of dev data but we only plot data points corresponding to the months of the year. An interesting pattern emerges in the Word space, where May is separated from the rest of the months because May has multiple meanings in the English language. The contextual embedding layer uses contextual cues from surrounding words and is able to separate the usages of the word May. Finally we visualize the attention matrices for some question-context tuples in the dev data in Figure 3. In the first example, Where matches locations and in the second example, many matches quantities and numerical symbols. Also, entities in the question typically attend to the same entities in the context, thus providing a feature for the model to localize possible answers.
We analyse the performance of our our model with a traditional language-feature-based baseline (Rajpurkar et al., 2016). Figure 2b shows a Venn diagram of the dev set questions correctly answered by the models. Our model is able to answer more than 86% of the questions correctly answered by the baseline. The 14% that are incorrectly answered does not have a clear pattern. This suggests that neural architectures are able to exploit much of the information captured by the language features. We also break this comparison down by the first words in the questions (Figure 2c). Our model outperforms the traditional baseline comfortably in every category.
We randomly select 50 incorrect questions (based on EM) and categorize them into 6 classes. 50% of errors are due to the imprecise boundaries of the answers, 28% involve syntactic complications and ambiguities, 14% are paraphrase problems, 4% require external knowledge, 2% need multiple sentences to answer, and 2% are due to mistakes during tokenization. See Appendix A for the examples of the error modes.
We also evaluate our model on the task of cloze-style reading comprehension using the CNN and Daily Mail datasets (Hermann et al., 2015).
In a cloze test, the reader is asked to fill in words that have been removed from a passage, for measuring one’s ability to comprehend text. Hermann et al. (2015) have recently compiled a massive Cloze-style comprehension dataset, consisting of 300k/4k/3k and 879k/65k/53k (train/dev/test) examples from CNN and DailyMail news articles, respectively. Each example has a news article and an incomplete sentence extracted from the human-written summary of the article. To distinguish this task from language modeling and force one to refer to the article to predict the correct missing word, the missing word is always a named entity, anonymized with a random ID. Also, the IDs must be shuffled constantly during test, which is also critical for full anonymization.
The model architecture used for this task is very similar to that for SQuAD (Section 4) with only a few small changes to adapt it to the cloze test. Since each answer in the CNN/DailyMail datasets is always a single word (entity), we only need to predict the start index (); the prediction for the end index (
) is omitted from the loss function. Also, we mask out all non-entity words in the final classification layer so that they are forced to be excluded from possible answers. Another important difference from SQuAD is that the answer entity might appear more than once in the context paragraph. To address this, we follow a similar strategy fromKadlec et al. (2016). During training, after we obtain , we sum all probability values of the entity instances in the context that correspond to the correct answer. Then the loss function is computed from the summed probability. We use a minibatch size of 48 and train for 8 epochs, with early stop when the accuracy on validation data starts to drop. Inspired by the window-based method (Hill et al., 2016), we split each article into short sentences where each sentence is a 19-word window around each entity (hence the same word might appear in multiple sentences). The RNNs in BiDAF are not feed-forwarded or back-propagated across sentences, which speed up the training process by parallelization. The entire training process takes roughly 60 hours on eight Titan X GPUs. The other hyper-parameters are identical to the model described in Section 4.
The results of our single-run models and competing approaches on the CNN/DailyMail datasets are summarized in Table 3. indicates ensemble methods. BiDAF outperforms previous single-run models on both datasets for both val and test data. On the DailyMail test, our single-run model even outperforms the best ensemble method.
|Attentive Reader (Hermann et al., 2015)||61.6||63.0||70.5||69.0|
|MemNN (Hill et al., 2016)||63.4||6.8||-||-|
|AS Reader (Kadlec et al., 2016)||68.6||69.5||75.0||73.9|
|DER Network (Kobayashi et al., 2016)||71.3||72.9||-||-|
|Iterative Attention (Sordoni et al., 2016)||72.6||73.3||-||-|
|EpiReader (Trischler et al., 2016)||73.4||74.0||-||-|
|Stanford AR (Chen et al., 2016)||73.8||73.6||77.6||76.6|
|GAReader (Dhingra et al., 2016)||73.0||73.8||76.7||75.7|
|AoA Reader (Cui et al., 2016)||73.1||74.4||-||-|
|ReasoNet (Shen et al., 2016)||72.9||74.7||77.6||76.6|
|MemNN (Hill et al., 2016)||66.2||69.4||-||-|
|ASReader (Kadlec et al., 2016)||73.9||75.4||78.7||77.7|
|Iterative Attention (Sordoni et al., 2016)||74.5||75.7||-||-|
|GA Reader (Dhingra et al., 2016)||76.4||77.4||79.1||78.1|
|Stanford AR (Chen et al., 2016)||77.2||77.6||80.2||79.2|
In this paper, we introduce BiDAF, a multi-stage hierarchical process that represents the context at different levels of granularity and uses a bi-directional attention flow mechanism to achieve a query-aware context representation without early summarization. The experimental evaluations show that our model achieves the state-of-the-art results in Stanford Question Answering Dataset (SQuAD) and CNN/DailyMail cloze test. The ablation analyses demonstrate the importance of each component in our model. The visualizations and discussions show that our model is learning a suitable representation for MC and is capable of answering complex questions by attending to correct locations in the given paragraph. Future work involves extending our approach to incorporate multiple hops of the attention layer.
This research was supported by the NSF (IIS 1616112), NSF (III 1703166), Allen Institute for AI (66-9175), Allen Distinguished Investigator Award, Google Research Faculty Award, and Samsung GRO Award. We thank the anonymous reviewers for their helpful comments.
Ask your neurons: A neural-based approach to answering questions about images.In ICCV, 2015.
Table 4 summarizes the modes of errors by BiDAF and shows examples for each category of error in SQuAD.
|Error type||Ratio (%)||Example|
|Imprecise answer boundaries||50||
Context: “The Free Movement of Workers Regulation articles 1 to 7 set out the main provisions on equal treatment of workers.”
Question: “Which articles of the Free Movement of Workers Regulation set out the primary provisions on equal treatment of workers?”
Prediction: “1 to 7”, Answer: “articles 1 to 7”
|Syntactic complications and ambiguities||28||
Context: “A piece of paper was later found on which Luther had written his last statement. ”
Question: “What was later discovered written by Luther?”
Prediction: “A piece of paper”, Answer: “his last statement”
Context: “Generally, education in Australia follows the three-tier model which includes primary education (primary schools), followed by secondary education (secondary schools/high schools) and tertiary education (universities and/or TAFE colleges).”
Question: “What is the first model of education, in the Australian system?”
Prediction: “three-tier”, Answer: “primary education”
Context: “On June 4, 2014, the NFL announced that the practice of branding Super Bowl games with Roman numerals, a practice established at Super Bowl V, would be temporarily suspended, and that the game would be named using Arabic numerals as Super Bowl 50 as opposed to Super Bowl L.”
Question: “If Roman numerals were used in the naming of the 50th Super Bowl, which one would have been used?’
Prediction: “Super Bowl 50”, Answer: “L”
Context: “Over the next several years in addition to host to host interactive connections the network was enhanced to support terminal to host connections, host to host batch connections (remote job submission, remote printing, batch file transfer), interactive file transfer, gateways to the Tymnet and Telenet public data networks, X.25 host attachments, gateways to X.25 data networks, Ethernet attached hosts, and eventually TCP/IP and additional public universities in Michigan join the network. All of this set the stage for Merit’s role in the NSFNET project starting in the mid-1980s.”
Question: “What set the stage for Merits role in NSFNET”
Prediction: “All of this set the stage for Merit ’s role in the NSFNET project starting in the mid-1980s”, Answer: “Ethernet attached hosts, and eventually TCP/IP and additional public universities in Michigan join the network”
Context: “English chemist John Mayow (1641-1679) refined this work by showing that fire requires only a part of air that he called spiritus nitroaereus or just nitroaereus.”
Question: “John Mayow died in what year?”
Prediction: “1641-1679”, Answer: “1679”
Error analysis on SQuAD. We randomly selected EM-incorrect answers and classified them into 6 different categories. Only relevant sentence(s) from the context shown for brevity.
|Eqn. 1: dot product||65.5||75.5|
|Eqn. 1: linear||59.5||69.7|
|Eqn. 1: bilinear||61.6||71.8|
|Eqn. 1: linear after MLP||66.2||76.4|
|Eqn. 2: MLP after concat||67.1||77.0|
In this appendix section, we experimentally demonstrate how different choices of the similarity function (Equation 1) and the fusion function (Equation 2) impact the performance of our model. Each variation is defined as following:
Dot product is defined as
where indicates matrix transpose. Dot product has been used for the measurement of similarity between two vectors by Hill et al. (2016).
Linear is defined as
where is a trainable weight matrix. This can be considered as the simplification of Equation 1 by dropping the term in the concatenation.
Bilinear is defined as
where is a trainable weight matrix. Bilinear term has been used by Chen et al. (2016).
We can also perform linear mapping after single layer of perceptron:
where and are trainable weight matrix and bias, respectively. Linear mapping after perceptron layer has been used by Hermann et al. (2015).
We can define as
are trainable weight matrix and bias. This is equivalent to adding ReLU after linearly transforming the original definition of. Since the output dimension of changes, the input dimension of the first LSTM of the modeling layer will change as well.
The results of these variations on the dev data of SQuAD are shown in Table 5. It is important to note that there are non-trivial gaps between our definition of and other definitions employed by previous work. Adding MLP in does not seem to help, yielding slightly worse result than without MLP.