Title: BUILDING DYNAMIC KNOWLEDGE GRAPHS FROM TEXT USING MACHINE READING COMPREHENSION

Abstract: 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 PROPARA dataset (Dalvi et al., 2018) , our model achieves state-of-the-art results. The model also outperforms previous approaches on the RECIPES 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.

1. INTRODUCTION:

Automatically building knowledge graphs (KGs) from text is a long-standing goal in artificial 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, scientific 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, KG-MRC, 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. Figure 1 : Snapshot of the knowledge graphs created by our model before and after reading the sentence in boldface. Since the KG explicitly stores the current location of light, CO 2 , and water as leaf, the model can infer that mixture is formed in the leaf even though this is not explicitly stated. The three participant entities also get destroyed in the process, which is captured in the graph by pointing to a special Nowhere node.

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 PROPARA and RECIPES 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 (KG-MRC) on the above two PROPARA tasks and find that the same model significantly outperforms the previous state of the art. For example, KG-MRC obtains a 9.92% relative improvement on the hard task of predicting at which time-step an entity moves. Similarly on the latter task, KG-MRC obtains a 5.7% relative improvement over PROSTRUCT and 41% relative improvement over other entity-centric models such as ENTNET (Henaff et al., 2017) . The same model also obtains state-of-the-art performance on the RECIPES dataset.

2. RELATED WORK:

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 ENTNET (Henaff et al., 2017) and Query Reduction Networks (Seo et al., 2017b) fail to perform well on PROPARA.

PROREAD (Berant et al., 2014) introduced the PROCESSBANK dataset, which contains paragraphs of procedural text as in PROPARA. 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, KG-MRC, learns to build dynamic KGs just from annotations of text spans, which are much easier to collect.

For the sentence-level PROPARA task they propose, Dalvi et al. (2018) introduce two models: PROLOCAL and PROGLOBAL. PROLOCAL makes local predictions about entities by considering just the current sentence. This is followed by some heuristic/rule-based answer propagation. PROGLOBAL 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, (PROSTRUCT), where hard and soft common-sense constraints are injected to steer their model away from globally incoherent predictions. We evaluate KG-MRC on the two PROPARA tasks proposed by Dalvi et al. (2018) and Tandon et al. (2018) , respectively, and find that our single model outperforms each of the above models on their respective tasks of focus.

ENTNET (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. ENTNET maintains a dynamic memory of hidden states with a gated update to the memory slots at each step. Memory slots can be tied to specific entities, but unlike our model, ENTNET does not maintain separate embeddings of individual states (e.g., current locations); it also does not perform explicit co-reference updates. QRN refines 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 classification 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 (querification). 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 KG-MRC.

3. DATA & TASKS:

We evaluate KG-MRC on the recently released PROPARA dataset (Dalvi et al., 2018) , which comprises procedural text about scientific 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.

# para 488 # train/#dev/#test 391/43/54 avg. # entities 4.17 avg. # sentences 6.7 # sentences 3.3K 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 PROPARA. 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 fine-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 PROPARA 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? (3) What conversions occur, when and where? (4) What movements occur, when and where? Inputs to a process are defined 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, KG-MRC, on both tasks. Bosselut et al. (2018) recently released the RECIPES dataset, which has various annotated states (e.g. shape, composition, location, etc.) for ingredients in cooking recipes. We further test KG-MRC on the location task to align with our PROPARA experiments. This is arguably the dataset's hardest task, since it requires classification 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 classification over a fixed lexicon as in previous models, our model aims to find the location-describing span of text in the recipe paragraph.

4. MODEL:

KG-MRC 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. KG-MRC 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 . KG-MRC takes as input a paragraph p = {w j } P j=1 = {s t } T t=1 , consisting of P tokens spread across T sentences. The model reads this paragraph incrementally. Specifically, at each time step (sentence) t, the model reads the paragraph prefix 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 PROPARA 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 ith 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.1. ENTITY AND SPAN REPRESENTATIONS:

In the PROPARA dataset, entities appear in the paragraph text.1 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, 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, 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.2. MACHINE READING COMPREHENSION MODEL:

Rather than design a specialized MRC architecture, we make simple extensions to a widely used model -DRQA (Chen et al., 2017) -to adapt it to query about the evolving states of entities. In summary, our modified DRQA implementation operates on prefixes of sentences rather than the full paragraph (like PROGLOBAL), 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 DRQA 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, modified as described below.

We query the DRQA 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. (2017) . Our DRQA component also conditions on entities. Recall that vector e i,t-1 denotes the entity's representation in the knowledge graph G t-1 . The module conditions on e i,t-1 in its output layer, basically the same way as the question representation is used in the output alignment step in Chen et al. (2017) . However, instead of taking a bi-linear map between the question and passage representations as in that work, we first 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 arg max to obtain the most likely span. As mentioned, we encode this span as vector ψ i,t ( § 4.1).

The PROPARA 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 classifier 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.3. SOFT CO-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- 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

where

Λ t-1 = [λ i,t ] N i=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 λ 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

Λ t = [λ i,t ] N i=1 ∈ R N×d is a matrix of intermediate node representations (stacked row-wise) and U t = [u i,t ] N

i=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.4. GRAPH UPDATE:

The graph update proceeds according to the following set of equations for each update layer l:

EQUATION

We first compose all connected entity and location nodes with their history summary, h l i,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 final 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 Λl t , which is a row-wise stacked matrix of the λl i,t . The recurrent graph module stacks L such layers to propagate node information along the graph's edges. The resulting node representations are e L i,t and λ L i,t for each participant entity and its location. We use e i,t = e L i,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.5. TRAINING:

The full KG-MRC 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.

5. EXPERIMENTS AND DISCUSSION:

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.1. RESULTS ON PROCEDURAL TEXT:

We benchmarked our model on two PROPARA comprehension tasks introduced respectively in Dalvi et al. (2018) and Tandon et al. (2018) . 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 specific model for each task, whereas we test KG-MRC on both tasks. A primary motivation for building KGs is because they can be queried for salient knowledge in downstream applications. We evaluate KG-MRC on the above two tasks by querying the KGs it builds at each time-step; we use the official evaluation pipeline2 for each task. In results below, we report an average score of three runs of our model with different hyperparameter settings.

5.1.1. TASK 1: SENTENCE-LEVEL EVALUATION:

Table 3 shows our main results on the first 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, ENTNET (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 PROGLOBAL, which achieves 45.37%. Our KG-MRC improves over this result by 1.25% absolute score in terms of micro-averaged accuracy. Comparing various models for each subtask category, PROGLOBAL leads in Category 1 by a small margin of around 0.1%. For the more challenging Categories 2 and 3, KG-MRC outperforms PROGLOBAL by a large margin. These questions require fine-grained predictions of state changes. Table 3 : Task 1 results (accuracy).

5.1.2. TASK 2: DOCUMENT-LEVEL EVALUATION:

We report the performance of our model on the document-level task, along with previously published results, in Table 4 . The same KG-MRC model achieves 3.02% absolute improvement in F 1 over the previous best result of PROSTRUCT. PROSTRUCT incorporates a set of commonsense constraints for globally consistent predictions. We analyzed KG-MRC'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.4. 

5.2. RECIPE DESCRIPTION EXPERIMENTS:

We also evaluate our model on the RECIPES 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 classification over a fixed lexicon of locations. KG-MRC searches for the correct location span in the text. On this task, our model outperforms the baseline NPN model by a significant 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.3. ABLATION STUDY:

We performed an ablation study to evaluate different model variations on PROPARA Task 1. The main results are reported in Table 5 . Removing the soft co-reference disambiguation within time steps (Equations 2) from KG-MRC resulted in around 1% performance drop. The drop is more significant 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 final 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 prefix 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 prefixes already provides a good starting performance of 40.83% micro-average, which is significantly boosted by the recurrent graph module and graph conditioning up to 47.64%. 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 KG-MRC learns to violate fewer constraints (proportionally) than PROSTRUCT, even without explicitly training it to do so. In more detail, we find that KG-MRC, like PROSTRUCT, 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. As shown, KG-MRC makes fewer Type 3 violations that PROSTRUCT. Furthermore, MRC models without recurrent graph modules perform worse in terms of constraint violations than both KG-MRC 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.5. QUALITATIVE ANALYSIS:

We picked an example from the test data and took a closer look at the model outputs to investigate how KG-MRC dynamically adjusts its decisions via the dynamic graph module and finds accurate spans with the conditional MRC model. The step-by-step output of both PROGLOBAL (Dalvi et al. (2018) ) and KG-MRC is shown in Table 7 , where we track the state of entity blood across six sentences. KG-MRC outputs smoother and more accurate predictions. 

6. CONCLUSION:

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, KG-MRC, achieves state-of-theart results on two question-answering tasks from the PROPARA dataset and one from the RECIPES dataset. In future work, we will extend the model to construct more general knowledge graphs with multiple relation types.

:

We compute the positions of the occurrence of entities by simple string matching.

https://github.com/allenai/propara/tree/master/propara/eval

Figures and Tables:

Figure 2: Soft co-reference across time steps. The sentence at the current time step is highlighted. When the MRC model predicts a span (leaf ) present in the graph at the previous time step, KG-MRC does soft attention and a gated update to preserve information across time steps ( § 4.3). The thicker arrow shows higher attention weight between the old and new node.

Statistics of PROPARA.

Table content: <table/>

Number of participant entities in the process. ν i ∈ R d Initial entity representation, derived from the text, for the i-th entity at time t = 0 ( § 4.1) e i,t ∈ R d Entity node representation for the i-th entity at time t, in the graph G t ( § 4.4) ψ i,t ∈ R d Location representation derived from the text for the i-th entity at time t ( § 4.1) λ i,t ∈ R d Location node representation for the i-th entity at time t, in the graph G t ( § 4.3, 4.4) Λ t ∈ R N×dMatrix of all location node representations at time t. (Essentially all λ i,t stacked row-wise at t) U t ∈ R N×N Soft co-reference matrix at time step t ( § 4.3) Symbols used in Section 4. The text-based representations of entities and locations are derived from the hidden representations of the context-RNN ( § 4.1). The node representations are added to the graph G t at the end of time step t ( § 4.4).

Table content: <table><tr><td>Notation</td><td>Meaning</td></tr><tr><td>N ∈ N</td><td/></tr></table>

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.

Table content: <table><tr><td/><td/><td/><td/><td/><td>Where is water</td></tr><tr><td colspan="5">Chloroplast in leaf of the plant trap</td><td>located?</td></tr><tr><td colspan="5">light from the sun. The root absorbs</td><td/><td>New node at</td></tr><tr><td>minerals</td><td>from</td><td>the</td><td>soil.</td><td>This</td><td/><td>time t</td></tr><tr><td colspan="6">combination of MRC model</td><td>leaf</td></tr><tr><td/><td/><td/><td/><td/><td colspan="2">Soft co-reference</td></tr><tr><td/><td/><td/><td/><td/><td colspan="2">across time-steps</td></tr><tr><td/><td/><td/><td/><td>Light</td><td>CURRENT LOCATION</td><td>leaf</td></tr><tr><td/><td/><td/><td/><td>Water</td><td>CURRENT LOCATION</td><td>root</td></tr><tr><td/><td/><td/><td/><td>Co2</td><td>CURRENT LOCATION</td><td>Nowhere</td></tr><tr><td/><td/><td/><td/><td colspan="3">Knowledge graph at time (t-1)</td></tr><tr><td colspan="3">Graph at time (t-1)</td><td/><td/><td/></tr></table>

Task 2 results.

Table content: <table/>

For accurate, globally consistent predictions on the second PROPARA task,Tandon et al. (2018) introduced a set of commonsense constraints that they impose on their model in a pruning stage. Stated in natural 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.

Table content: <table><tr><td/><td>Cat 1</td><td>Cat 2</td><td>Cat 3</td><td>Macro-avg</td><td>Micro-avg</td></tr><tr><td>KG-MRC</td><td>58.55</td><td>38.52</td><td>42.22</td><td>46.43</td><td>47.64</td></tr><tr><td>-Coref across time steps</td><td>61.07</td><td>37.38</td><td>35.58</td><td>44.68</td><td>46.32</td></tr><tr><td>-Coref within time step</td><td>57.88</td><td>38.09</td><td>40.19</td><td>45.39</td><td>46.63</td></tr><tr><td>-Coref in the graph-update step</td><td>60.91</td><td>34.71</td><td>32.34</td><td>42.65</td><td>44.48</td></tr><tr><td>Standard LSTM as graph unit</td><td>56.84</td><td>13.15</td><td>10.95</td><td>26.98</td><td>29.97</td></tr><tr><td>MRC on entire paragraph</td><td>58.85</td><td>21.82</td><td>26.52</td><td>35.73</td><td>35.98</td></tr><tr><td>MRC on prefix</td><td>61.28</td><td>32.58</td><td>29.48</td><td>41.11</td><td>40.83</td></tr><tr><td colspan="5">Table 5: Ablation experiment results</td><td/></tr><tr><td>5.4 COMMONSENSE CONSTRAINTS</td><td/><td/><td/><td/><td/></tr></table>

Commonsense constraint violations.

Table content: <table><tr><td>Model</td><td>State Change Predictions</td><td>Violations</td><td>Violation Proportion (%)</td></tr><tr><td>PROSTRUCT (Tandon et al. (2018))</td><td>270</td><td>17</td><td>6.30</td></tr><tr><td>MRC on entire paragraph</td><td>381</td><td>104</td><td>27.30</td></tr><tr><td>MRC on prefix</td><td>703</td><td>154</td><td>21.93</td></tr><tr><td>Standard LSTM as graph unit</td><td>447</td><td>20</td><td>4.47</td></tr><tr><td>KG-MRC</td><td>466</td><td>19</td><td>4.08</td></tr></table>

Two models' predictions of entity locations, on randomly selected paragraph about blood circulation. In this example the entity is blood. Predicted results from Pro-Local(Dalvi et al. (2018)) are in orange, results from KG-MRC are in red, important locations in paragraph are in blue.

Table content: <table><tr><td>Sentences</td><td colspan="2">Location of entities after each sentence</td></tr><tr><td>(Before first sentence)</td><td>somewhere</td><td>somewhere</td></tr><tr><td>Blood enters the right side of your heart.</td><td>heart</td><td>right side of your heart</td></tr><tr><td>Blood travels to the lungs.</td><td>lung</td><td>lungs</td></tr><tr><td>Carbon dioxide is removed from the blood.</td><td>blood</td><td>lungs</td></tr><tr><td>Oxygen is added to your blood.</td><td>lung</td><td>lungs</td></tr><tr><td>Blood returns to left side of your heart.</td><td>blood</td><td>heart</td></tr><tr><td>The blood travels through the body.</td><td>body</td><td>body</td></tr></table>

Peer review (iclr2019):
 The paper proposes a recurrent knowledge graph (bipartite graph between entities and location nodes) construction & updating mechanism for entity state tracking datasets such as (two) ProPara tasks and Recipes. The model goes through the following three steps: 1) it reads a sentence at each time step t and identifies the location of each entity via machine reading comprehension model such as DrQA (entities are predefined). 2) Co-reference module adjusts relationship scores (soft adjacency matrix) among nodes, including possibly new nodes introduced by the MRC model. 3) to propagate the relational information across all the nodes, the model performs L layers of LSTM for each entity that attend on other nodes via attention (where the weights come from the adjacency matrix). The model repeats the three steps for each sentence. The model is trained by directly supervising for the correct span by the MRC model at each time step, which is possible because the data provides strong supervision for each sentence (not just the answer at the end). The model achieves the state of the art in the two tasks of ProPara and Recipes dataset. Strengths: The paper provides an elegant solution for tracking relationship between entities as time (sentence) progresses. I also agree with the authors that this line of work (dynamic KG construction and modification) is an important area of research. While the model shares a similar spirit to EntNet, I think the model has enough distinctions / contributions, especially given that it outperforms EntNet by a large margin. The model also obtains non-trivial improvement over previous SOTA models. Weaknesses: Paper could have been written better. I had hard time understanding it. The notations are overall confusing and not explained well. Also there are a few unclear parts which I discuss in questions below. Questions: 1. Are e_{i,t} and lambda_{i,t} vectors? Scalars? Abstract node notations? It is not clear in the model section. Also, it took me a long time to figure out that ‘i’ is used to index each entity (it is mentioned later). 2. The paper says v_i (initial representation of each entity) is obtained by looking at the contextualized representations (LSTM outputs) of entity mention in the context. What happens if there are multiple mentions in the text? Which one does it look at? 3. For the LSTM in the graph update, why does it have only one input? Shouldn’t it have two inputs, one for previous hidden state and the other for input? 4. Regarding Recipe experiments, the paper says it reaches a better performance than the baseline using just 10k examples out of 60k. This is great, but could you also report the number when the full dataset is used? 5. What does it mean that in training time the model “updates” the location node representation with the encoding of correct span. Do you mean you use the encoding instead? 6. For ProPara task 2, what threshold did you choose to obtain the P/R/F1 score? Is it the threshold that maximizes F1?