B UILDING D YNAMIC K NOWLEDGE G RAPHS FROM T EXT USING M ACHINE R EADING C OMPREHENSION
A BSTRACT
We propose a neural machine reading model that constructs dynamic knowledge graphs from procedural text.
It builds these graphs recurrently for each step of the described procedure, and uses them to track the evolving states of participant entities.
We harness and extend a recently proposed machine reading comprehension (MRC) model to query for entity states, since these states are generally communicated in spans of text and MRC models perform well in extracting entity-centric spans.
The explicit, structured, and evolving knowledge graph representations that our model constructs can be used in downstream question answering tasks to improve machine comprehension of text, as we demonstrate empirically.
On two comprehension tasks from the recently proposed P RO P ARA dataset (Dalvi et al., 2018), our model achieves state-of-the-art results.
The model also outperforms previous approaches on the R ECIPES dataset (Kiddon et al., 2015), which suggests it may apply broadly to procedural text.
Finally, we present some evidence that the model’s graphical representations help it to impose commonsense constraints on its predictions.
I NTRODUCTION
Automatically building knowledge graphs (KGs) from text is a long-standing goal in artiﬁcial intelligence research.
KGs organize raw information in a structured form, capturing relationships (labeled edges) between entities (nodes).
They enable automated reasoning, e.g., the ability to infer unobserved facts from observed evidence and to make logical “hops,” and render data amenable to decades of work in graph analysis.
There exists a profusion of text that describes complex, dynamic worlds in which entities’ relationships evolve through time.
This includes news articles, scientiﬁc manuals, and procedural text (e.g., recipes, how-to guides, and so on).
Building KGs from this data would not only help us to study the changing relations among participant entities, but also to make implicit information more explicit.
For example, the graphs at each step in Figure 1 help us to infer that the new entity mixture is created in the leaf , since the previous location of its participant entities ( light, CO 2 , water ) was leaf – even though this is never stated in the text.
This paper introduces a neural machine-reading model, K G -M RC , that (i) explicitly constructs dynamic knowledge graphs to track state changes in procedural text and (ii) conditions on its own constructed knowledge graphs to improve downstream question answering on the text.
Our dynamic graph model is recurrent, that is, the graph at each time step depends on the state of the graph at the previous time step.
The constructed graphs are parameterized by real-valued embeddings for each node that change through time.
In text, entities and their states (e.g., their locations) are given by spans of words.
Because of the variety of natural language, the same entity/state may be described with several surface forms.
To
Chloroplast in leaf of the plant trap light from the sun.
The root absorbs minerals from the soil.
This combination of water and minerals flows from the stem into the leaf.
Carbon dioxide enters the leaf.
Light, water and minerals, and the carbon dioxide all combine into a mixture.
This mixture forms sugar (glucose) which is what the plant eats.
c u
rr e n t l o c a t i o n c u
rr e n t l o c
a t i o n c u rr e n t l o c a t i o n
Light
[Figure]
n
[Figure]
n
[Figure]
address the challenge of entity/state recognition, our model uses a machine reading comprehension (MRC) mechanism (Seo et al., 2017a; Xiong et al., 2017; Chen et al., 2017; Yu et al., 2018, inter alia), which queries for entities and their states at each time step. We leverage MRC mechanisms because they have proven adept at extracting text spans that answer entity-centric questions (Levy et al., 2017). However, such models are static by design, returning the same answer for the same query and context. Since we expect answers about entity states to change over the course of the text, our model’s MRC component conditions on the evolving graph at the current time step (this graph captures the instantaneous states of entities).
To address the challenge of aliased text mentions, our model performs soft co-reference as it updates the graph.
Instead of adding an alias node, like the leaf or leaves as aliases for leaf , the graph update procedure soft-attends (Bahdanau et al., 2014) over all nodes at the previous time step and performs a gated update (Cho et al., 2014; Chung et al., 2014) of the current embeddings with the previous ones.
This ensures that state information is preserved and propagated across time steps.
Soft coreference can also handle the case that entity states do not change across time steps, by applying a near-null update to the existing state node rather than duplicating it.
At each time step, after the graph has been updated with the (possibly) new states of all entities, our model updates each entity representation with information about its state.
The updated information about each individual entity is further propagated to all other entities (§ 4.4).
This enables the model to recognize, for example, that entities are present in the same location (e.g., light, CO 2 and water in
Figure 1).
Thus, our model can use the information encoded in its internal knowledge graphs for a more comprehensive understanding of the text.
We will demonstrate this experimentally by tackling comprehension tasks from the the recently released P RO P ARA and R ECIPES datasets.
Our complete machine reading model, which both builds and leverages dynamic knowledge graphs, can be trained end-to-end using only the loss from its MRC component; i.e., the negative loglikelihood that the MRC component assigns to the span that correctly describes each entity’s queried state.
We evaluate our model (K G -M RC ) on the above two P RO P ARA tasks and ﬁnd that the same model signiﬁcantly outperforms the previous state of the art.
For example, K G -M RC obtains a 9.92 % relative improvement on the hard task of predicting at which time-step an entity moves.
Similarly on the latter task, K G -M RC obtains a 5.7 % relative improvement over P RO S TRUCT and 41 % relative improvement over other entity-centric models such as E NT N ET (Henaff et al., 2017).
The same model also obtains state-of-the-art performance on the R ECIPES dataset.
R ELATED W ORK
There are few datasets that address the challenging problem of tracking entity state changes.
The bAbI dataset (Weston et al., 2015) includes questions about movement of entities; however, its language is generated synthetically over a small lexicon, and hence models trained on bAbI often do not generalize well when tested on real-world data.
For example, state-of-the-art models like
E NT N ET (Henaff et al., 2017) and Query Reduction Networks (Seo et al., 2017b) fail to perform well on P RO P ARA .
P RO R EAD (Berant et al., 2014) introduced the P ROCESS B ANK dataset, which contains paragraphs of procedural text as in P RO P ARA .
However, this earlier task involves mining arguments and relations from events, not tracking the dynamic state changes of entities.
The model that Berant et al.
(2014) propose builds small knowledge graphs from the text, but they are not dynamic in nature.
The model also relies on densely annotated process structure for training, demanding curation by domain experts.
On the other hand, our model, K G -M RC , learns to build dynamic KGs just from annotations of text spans, which are much easier to collect.
For the sentence-level P RO P ARA task they propose, Dalvi et al.
(2018) introduce two models:
P RO L OCAL and P RO G LOBAL .
P RO L OCAL makes local predictions about entities by considering just the current sentence.
This is followed by some heuristic/rule-based answer propagation.
P RO G LOBAL considers a broader context (previous sentences) and also includes the previous state of entities by considering the probability distribution over paragraph tokens in the previous step.
Tandon et al.
(2018) recently proposed a neural structured-prediction model, (P RO S TRUCT ), where hard and soft common-sense constraints are injected to steer their model away from globally incoherent predictions.
We evaluate K G -M RC on the two P RO P ARA tasks proposed by Dalvi et al.
(2018) and Tandon et al.
(2018), respectively, and ﬁnd that our single model outperforms each of the above models on their respective tasks of focus.
E NT N ET (Henaff et al., 2017) and query reduction networks (QRN) (Seo et al., 2017b) are two state-of-the-art entity-centric models for the bAbI dataset.
E NT N ET maintains a dynamic memory of hidden states with a gated update to the memory slots at each step.
Memory slots can be tied to speciﬁc entities, but unlike our model, E NT N ET does not maintain separate embeddings of individual states (e.g., current locations); it also does not perform explicit co-reference updates.
QRN reﬁnes the query vector as it processes each subsequent sentence until the query points to the answer, but does not maintain explicit representations of entity states.
Neural Process Networks (NPN) (Bosselut et al., 2018)
learn to understand procedural text by explicitly parameterizing actions and composing them with entities.
These three models return an answer by predicting a vocabulary item in a multi-class classiﬁcation setup, while in our work we predict spans of text directly from the paragraph.
MRC models have been used previously for extracting the argument of knowledge base (KB) relations, by associating one or more natural language questions with each relation ( queriﬁcation ).
These models have been shown to perform well in a zero-shot setting, i.e., for a previously unseen relation type (Levy et al., 2017), and for extracting entities that belong to non-standard types (Roth et al., 2018).
These recent positive results motivate our use of an MRC component in K G -M RC .
D ATA & T ASKS
We evaluate K G -M RC on the recently released P RO P ARA dataset (Dalvi et al., 2018), which comprises procedural text about scientiﬁc processes.
The location states of participant entities at each time step (sentence) in these processes are labeled by human annotators, and the names of participant entities are given.
As an example, for a process describing photosynthesis, the participant entities provided are: light, CO 2 , water, mixture and glucose .
Although participant entities are thus known a priori , the location of an entity could be any arbitrary span in the process text.
This makes the task of determining and tracking an entity’s changing location quite challenging.
[Table]
It should also be noted that the dataset does not provide information on whether a particular entity is an input to or output of a process.
Not all entities exist from the beginning of the process (e.g. glucose ) and not all exist at the end (e.g. water ).
Table 1 shows statistics of P RO P ARA .
As can be seen, the training set is small, which makes learning challenging.
Along with the dataset, Dalvi et al.
(2018) introduce the task of tracking state changes at a ﬁne-grained sentence level.
To solve this task, a model must answer three categories of questions (10 questions in total) about an entity E : (1) Is E created, (destroyed, moved) in the process?
(2) When (step #) is E created, (destroyed, moved)?
(3) Where is E created, (destroyed, moved from/to)?
Cat.
1 asks boolean questions about the existence and movement of entities.
Cat. 2 and 3 are harder tasks, as the model must correctly predict the step number at which a state changes as well as the correct locations (text spans) of entities at each step.
Tandon et al.
(2018) introduce a second task on the P RO P ARA dataset that measures state changes at a coarser process level.
To solve this task, a model must correctly answer the following four types of questions: (1) What are the inputs to the process?
(2) What are the outputs of the process?
What conversions occur, when and where?
(4) What movements occur, when and where?
Inputs to a process are deﬁned as entities that exist at the start of the process but not at the end and outputs are entities that exist at the end of the process and were created during it.
A conversion is when some entities are created and others destroyed, while movements refer to changes in location.
Dalvi et al.
(2018) and Tandon et al.
(2018) propose different models to solve each of these tasks separately, whereas we evaluate the same model, K G -M RC , on both tasks.
Bosselut et al.
(2018) recently released the R ECIPES dataset, which has various annotated states (e.g. shape, composition, location, etc.) for ingredients in cooking recipes.
We further test K G -M RC on the location task to align with our P RO P ARA experiments.
This is arguably the dataset’s hardest task, since it requires classiﬁcation over more than 260 classes while the others have a much smaller label space (maximum of 4).
Note that rather than treating this problem as classiﬁcation over a ﬁxed lexicon as in previous models, our model aims to ﬁnd the location-describing span of text in the recipe paragraph.
M ODEL
K G -M RC tracks the temporal state change of entities in procedural text.
Naturally, the model is entity-centric (Henaff et al., 2017; Bansal et al., 2017): it associates each participant entity of the procedural text with a unique node and embedding in its internal graph.
K G -M RC is also equipped with a neural machine reading comprehension model which is queried about the current location of each entity.
At a high level, the model operates as follows.
We summarize some important notation in Table 2.
K G -M RC takes as input a paragraph p = { w j } Pj =
= { s t } Tt = 1 , consisting of P tokens spread across T sentences.
The model reads this paragraph incrementally.
Speciﬁcally, at each time step (sentence) t , the model reads the paragraph preﬁx comprising all sentences up to and including s t .
We then engage the MRC module to query for the state of each participant entity (these participants are known in P RO P ARA a priori and we index them with i ).
The querying process conditions on both the input text and the constructed knowledge graph from the previous time step.
In response to a query, the MRC module returns a span from the text that describes the i th entity’s location at t .
We encode this into a vector representation.
Finally, conditioning on the span vectors for all entities, the model constructs the graph G t by updating graph G t − 1 from the previous time step.
The model’s knowledge graphs G t are bipartite, having two sets of nodes with implied connections between them: G t = { e i , t , λ i , t } .
Each node denotes either an entity ( e i , t ) or that entity’s corresponding location ( λ i , t ), and is associated with a real-valued vector.
We use e i , t and λ i , t to denote nodes in the graph and their vector representations interchangeably.
The bipartite graphs G t have only one (implicit) relation type, the current location, though we plan to extend this in future work.
To derive
G t from its previous iterate G t − 1 , we combine both hard and soft graph updates.
The update to an entity’s node representation with new location information arises from a hard decision made by the
MRC model, whereas co-reference between entities across time steps is resolved with soft attention.
We now describe all components of the model in detail.
4. E NTITY AND S PAN R EPRESENTATIONS
In the P RO P ARA dataset, entities appear in the paragraph text.
Therefore, we derive the initial entity representations from contextualized hidden vectors by encoding the paragraph with a bi-directional
LSTM (Hochreiter & Schmidhuber, 1997).
This choice has the added advantage that initial entity representations share information through context, unlike in previous models (Henaff et al., 2017;
Das et al., 2017; Bansal et al., 2017).
Entities in the dataset can be multi-word expressions (e.g., electric oven ).
To obtain a single representation, we concatenate the contextualized hidden vectors corresponding to the start and end span tokens and take a linear projection.
i.e., if the mention of entity i occurs between the j -th and j + k -th position, then the initial entity representation
ν
i is computed as ν i =
W e
[ c j ; c j + k ] + b e .
We use i to index an entity and its corresponding location, [Table] while c j represents the contextualized hidden vectors for token j and [ ; ] represents the concatenate operation.
An entity may occur multiple times within a paragraph.
We give equal importance to all occurrences by summing the representations for each.
When queried about the current location of an entity [Table] the MRC module (§ 4.2) returns a span of text as the answer, whose representation is later used to update the appropriate node vector in the graph.
We obtain this answer-span representation analogously as above, and denote it with ψ i , t .
4. M ACHINE R EADING C OMPREHENSION M ODEL
Rather than design a specialized MRC architecture
[Table]
we make simple extensions to a widely used model – D R QA (Chen et al., 2017) – to adapt it to query about the evolving states of entities.
In summary, our modiﬁed D R QA implementation operates on preﬁxes of sentences rather than the full paragraph (like P RO G LOBAL ), and at each sentence (time step) it conditions on both the current sentence representation s t and the dynamic entity representations in G t − 1 .
For complete details of the D R QA model, we refer readers to the original publication (Chen et al., 2017).
Broadly, it uses a multi-layer recurrent neural network (RNN) architecture for encoding both the passage and question text and uses self-attention to match these two encodings.
For each token j in the text, it outputs a score indicating its likelihood of being the start or end of the span that answers the question.
We reuse all of these operations in our model, modiﬁed as described below.
We query the D R QA model about the state of each participant entity at each time step t .
This involves reading the paragraph up to and including sentence s t .
To query, we generate simple natural language questions for an entity, E , such as “Where is E located?”
This is motivated by the work of Levy et al.
Our D R QA component also conditions on entities.
Recall that vector e i , t −denotes the entity’s representation in the knowledge graph G t − 1 .
The module conditions on e i , t −in its output layer, basically the same way as the question representation is used in the output alignment step in Chen et al.
However, instead of taking a bi-linear map between the question and passage representations as in that work, we ﬁrst concatenate the question representation with e i , t − 1 and pass the concatenation through a 2-layer MLP.
This yields an entity-dependent question representation.
We use this to compute the output start and end scores for each token position, taking the argmax to obtain the most likely span.
As mentioned, we encode this span as vector ψ i , t (§ 4.1).
The P RO P ARA dataset includes two special locations that don’t appear as text spans: nowhere and somewhere .
The current location of an entity is nowhere when the entity does not exist yet or has been destroyed, whereas it is somewhere when the entity exists but its location is unknown from the text.
Since these locations don’t appear as tokens in the text, the span-predictive MRC module cannot extract them.
Following Dalvi et al.
(2018), we address this with a separate classiﬁer that predicts, given a graph entity node and the text, whether the entity represented by the node is nowhere , somewhere , or its location is stated.
We learn the location-node representations for nowhere and somewhere during training.
4. S OFT C O - REFERENCE
To handle cases when entity states do not change and when states are referred to with different surface forms (either of which could lead to undesired node duplication), our model uses soft co- [Figure]
which is
[Figure]
the
[Figure]
MRC
[Figure]
Where is water located? [Figure] reference mechanisms (Figure 2) both across and within time steps. Disambiguation across time steps is accomplished by attention and a gated update, using the incoming location vector ψ i , t and the location node representations from the previous time step:
[Equation]
(1) where Λ t − 1 =
[ λ i , t ] Ni = 1 ∈ R N × d is a matrix of location node representations from the previous time step (stacked row-wise) and ψ i , t is the location span vector output by the MRC module.
The result vector λ (cid:48)
i , t is a disambiguated intermediate node representation.
This process only partially addresses node de-duplication.
Since different instances of the same location can be predicted for multiple entities, we also perform a co-reference disambiguation within each time step using a self-attention mechanism:
[Equation]
where Λ (cid:48) t = [ λ (cid:48)
i , t ] Ni = 1 ∈ R N × d is a matrix of intermediate node representations (stacked row-wise) and
U t =
[ u i , t ] Ni = 1 ∈ R N × N is a co-reference adjacency matrix.
We calculate this adjacency matrix at the beginning of each time step to track related nodes within t , and re-use it in the graph update step.
4. G RAPH U PDATE
The graph update proceeds according to the following set of equations for each update layer l :
[Equation]
We ﬁrst compose all connected entity and location nodes with their history summary, h li , t − 1 , using an LSTM unit.
Next, the updated node information is attached to the entity and location representations through two residual updates (He et al., 2016).
These propagate information between the entity and location representations; i.e., if two entities are at the same location, then the corresponding entity representations will receive a similar update.
Likewise, location representations are updated with pertinent entity information.
Last, we perform another co-reference pooling operation for the location nodes.
After the recurrent and residual graph updates, information propagation may yield different, diverging representations for nodes that belong to the same location.
This ﬁnal pooling operation corrects for this, by tying the co-referent representations in a soft way.
It uses the previously computed adjacency matrix U t and ˜ Λ lt , which is a row-wise stacked matrix of the ˜ λ li , t .
The recurrent graph module stacks L such layers to propagate node information along the graph’s edges.
The resulting node representations are e Li , t and λ Li , t for each participant entity and its location.
We use e i , t = e Li , t to condition the MRC model, as described in §4.2.
We make use of this particular graph module structure, rather than adopting an existing model like GraphCNNs (Edwards & Xie, 2016; Kipf & Welling, 2017), because recurrent networks are designed to propagate information through time.
4. T RAINING
The full K G -M RC model is trained end-to-end by minimizing the negative log-likelihood of the correct span tokens under the MRC module’s output distribution and the textual entailment model.
This is a fairly soft supervision signal, since we do not train the graph construction modules directly.
We teacher-force the model at training time by updating the location-node representations with the encoding of the correct span.
We do not pretrain the MRC module, but we represent paragraph tokens with pretrained FastText embeddings (Joulin et al., 2016).
See the appendix A for full implementation and training details.
E XPERIMENTS AND D ISCUSSION
We evaluate our model on three different tasks.
We also provide an ablation study along with quantitative and qualitative analyses to highlight the performance contributions of each module.
5. R ESULTS ON P ROCEDURAL T EXT
We benchmarked our model on two P RO P ARA comprehension tasks introduced respectively in Dalvi et al.
(2018) and Tandon et al.
Refer to Section 3 for a detailed description about the data and tasks.
Dalvi et al.
(2018) and Tandon et al.
(2018) respectively introduce a speciﬁc model for each task, whereas we test K G -M RC on both tasks.
A primary motivation for building KGs is because they can be queried for salient knowledge in downstream applications.
We evaluate K G -M RC on the above two tasks by querying the KGs it builds at each time-step; we use the ofﬁcial evaluation pipeline 2 for each task.
In results below, we report an average score of three runs of our model with different hyperparameter settings.
5.1. T ASK 1: S ENTENCE - LEVEL E VALUATION
Table 3 shows our main results on the ﬁrst task.
Following the original task evaluation, we report model accuracy on each subtask category and macro and micro averages over the subtasks.
Human performance is 79.69%, micro-average.
A state-of-the-art memory augmented network,
E NT N ET (Henaff et al., 2017), which is built to track entities but lacks an explicit graph structure, achieves 25.96%.
The previous best performing model is P RO G LOBAL , which achieves 45.37%.
Our K G -M RC improves over this result by 1.25% absolute score in terms of micro-averaged accuracy.
Comparing various models for each subtask category, P RO G LOBAL leads in Category 1 by a small margin of around 0.1%.
For the more challenging Categories 2 and 3, K G -M RC outperforms
P RO G LOBAL by a large margin.
These questions require ﬁne-grained predictions of state changes.
[Table]
5.1. T ASK 2: D OCUMENT - LEVEL E VALUATION
We report the performance of our model on the document-level task, along with previously published results, in Table 4.
The same K G -M RC model achieves 3.02% absolute improvement in F 1 over the previous best result of P RO S TRUCT .
P RO S TRUCT incorporates a set of commonsense constraints for globally consistent predictions.
We analyzed K G -M RC ’s outputs and were surprised to discover that our model learns these commonsense constraints from the data in an end-to-end fashion, as we show quantitatively in §5.
[Table]
5. R ECIPE D ESCRIPTION E XPERIMENTS
We also evaluate our model on the R ECIPES dataset, for which we predict the evolving locations of cooking ingredients.
In the original work of Bosselut et al.
(2018), they treat this problem as classiﬁcation over a ﬁxed lexicon of locations.
K G -M RC searches for the correct location span in the text.
On this task, our model outperforms the baseline NPN model by a signiﬁcant margin, achieving a score of 54.27 % F 1 compared to NPN’s 51.28% F 1 .
On further analysis of the results, we found several cases where our model was wrongly penalized, e.g., for predicting the span “saucepan” when the ground truth class label was “pan.”
We believe that our results would improve further if we mapped our predicted spans to the ground truth class labels.
5. A BLATION S TUDY
We performed an ablation study to evaluate different model variations on P RO P ARA Task 1.
The main results are reported in Table 5.
Removing the soft co-reference disambiguation within time steps (Equations 2) from K G -M RC resulted in around 1% performance drop.
The drop is more signiﬁcant when the co-reference disambiguation across time steps (Equations 1) is removed.
We also replaced the recurrent graph module with the standard LSTM unit and used the LSTM hidden state for the entity representation.
Because this model variant does not propagate information across graph nodes (the ﬁnal step in Equations 3), we observed a large performance decrease.
For the last two variations, we simply train the MRC model in isolation and predict location spans from the current sentence or paragraph preﬁx text (i.e., the current and all previous sentences).
These models construct no internal knowledge graphs.
We can see that training the MRC model on paragraph preﬁxes already provides a good starting performance of 40.83% micro-average, which is signiﬁcantly boosted by recurrent module and graph conditioning
[Table]
5. C OMMONSENSE C ONSTRAINTS
For accurate, globally consistent predictions on the second P RO P ARA task, Tandon et al.
(2018) introduced a set of commonsense constraints that they impose on their model in a pruning stage.
Stated in natural language, these constraints are: 1) An entity must exist before it can be moved or destroyed ; 2)
An entity cannot be created if it already exists ; 3) An entity cannot change until it is mentioned in the paragraph.
To analyze whether our model can learn these constraints directly from data, we count the number of model predictions that violate constraints on the test set.
To our surprise, this demonstrates that K GM RC learns to violate fewer constraints (proportionally) than P RO S TRUCT , even without explicitly training it to do so.
In more detail, we ﬁnd that K G -M RC , like P RO S TRUCT , does not violate any
Type 1 or Type 2 constraints.
In Table 6 we compare several models in terms of Type 3 constraint violations.
Note that we only count instances where a model predicts an entity state change.
[Table]
As shown, K G -M RC makes fewer Type 3 violations that P RO S TRUCT .
Furthermore, MRC models without recurrent graph modules perform worse in terms of constraint violations than both K GM RC and a model using a standard LSTM as its graph unit.
This suggests that recurrent graphical representations play an important role in helping the model to learn and adhere to the constraints.
5. Q UALITATIVE A NALYSIS
We picked an example from the test data and took a closer look at the model outputs to investigate how K G -M RC dynamically adjusts its decisions via the dynamic graph module and ﬁnds accurate spans with the conditional MRC model.
The step-by-step output of both P RO G LOBAL (Dalvi et al.
and K G -M RC is shown in Table 7, where we track the state of entity blood across six sentences.
K G -M RC outputs smoother and more accurate predictions.
[Table]
C ONCLUSION
We proposed a neural machine-reading model that constructs dynamic knowledge graphs from text to track locations of participant entities in procedural text.
It further uses these graphical representations to improve its downstream comprehension of text.
Our model, K G -M RC , achieves state-of-theart results on two question-answering tasks from the P RO P ARA dataset and one from the R ECIPES dataset.
In future work, we will extend the model to construct more general knowledge graphs with multiple relation types.
A I MPLEMENTATION D ETAILS
Implementation details of K G -M RC are as follows.
In all experiments, the word embeddings are initialized with FastText embeddings (Joulin et al., 2016); we use a document LSTM with two layers, the number of hidden units in each layer is 64.
We apply dropout rate of 0.4 in all recurrent layers, and 0.3 in all other layers.
The number of recurrent graph layers were set to ( L = 2).
The hidden unit size for the recurrent graph component was set to 64.
During training, the mini-batch size is 8.
We use adam (Kingma & Ba, 2014) as the step rule for optimization, The learning rate is set to 0.002.
The model is implemented using PyTorch (Paszke et al., 2017).