Original: G REASE LM: G RAPH REAS ONING E NHANCED L ANGUAGE M ODELS 
Revised: G REASE LM: G RAPH REAS ONING E NHANCED L ANGUAGE M ODELS FOR Q UESTION A NSWERING Anonymous authors

Original: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Answering complex questions about textual narratives requires reasoning over both stated context and the world knowledge that underlies it.
Revised: Answering complex questions about textual narratives requires reasoning over both stated context and the world knowledge that underlies it.

Original: However, pretrained language models (LM), the foundation of most modern QA systems, do not robustly represent latent relationships between concepts, which is necessary for reasoning.
Revised: However, pretrained language models (LM), the foundation of most modern QA systems, do not robustly represent latent relationships between concepts, which is necessary for reasoning.

Original: While knowledge graphs (KG) are often used to augment LMs with structured representations of world knowledge, it remains an open question how to effectively fuse and reason over the KG representations and the language context, which provides situational constraints and nuances.
Revised: While knowledge graphs (KG) are often used to augment LMs with structured representations of world knowledge, it remains an open question how to effectively fuse and reason over the KG representations and the language context, which provides situational constraints and nuances.

Original: In this work, we propose
Revised: In this work, we propose

Original: G REASE LM, a new model that fuses encoded representations from pretrained
Revised: G REASE LM, a new model that fuses encoded representations from pretrained

Original: LMs and graph neural networks over multiple layers of modality interaction operations.
Revised: LMs and graph neural networks over multiple layers of modality interaction operations.

Original: Information from both modalities propagates to the other, allowing language context representations to be grounded by structured world knowledge, and allowing linguistic nuances ( e.g. , negation, hedging) in the context to inform the graph representations of knowledge.
Revised: Information from both modalities propagates to the other, allowing language context representations to be grounded by structured world knowledge, and allowing linguistic nuances ( e.g. , negation, hedging) in the context to inform the graph representations of knowledge.

Original: Our results on three benchmarks in the commonsense reasoning ( i.e. , CommonsenseQA, OpenbookQA) and medical question answering ( i.e. , MedQA-USMLE) domains demonstrate that G REASE LM can more reliably answer questions that require reasoning over both situational constraints and structured knowledge, even outperforming models 8 × larger.
Revised: Our results on three benchmarks in the commonsense reasoning ( i.e. , CommonsenseQA, OpenbookQA) and medical question answering ( i.e. , MedQA-USMLE) domains demonstrate that G REASE LM can more reliably answer questions that require reasoning over both situational constraints and structured knowledge, even outperforming models 8 × larger.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Question answering is a challenging task that requires complex reasoning over both explicit constraints described in the textual context of the question, as well as unstated, relevant knowledge about the world ( i.e. , knowledge about the domain of interest).
Revised: Question answering is a challenging task that requires complex reasoning over both explicit constraints described in the textual context of the question, as well as unstated, relevant knowledge about the world ( i.e. , knowledge about the domain of interest).

Original: Recently, large pretrained language models ﬁne-tuned on QA datasets have become the dominant paradigm in NLP for question answering tasks (Khashabi et al., 2020).
Revised: Recently, large pretrained language models ﬁne-tuned on QA datasets have become the dominant paradigm in NLP for question answering tasks (Khashabi et al., 2020).

Original: After pretraining on an extreme-scale collection of general text corpora, these language models learn to implicitly encode broad knowledge about the world, which they are able to leverage when ﬁne-tuned on a domain-speciﬁc downstream QA task.
Revised: After pretraining on an extreme-scale collection of general text corpora, these language models learn to implicitly encode broad knowledge about the world, which they are able to leverage when ﬁne-tuned on a domain-speciﬁc downstream QA task.

Original: However, despite the strong performance of this two-stage learning procedure on common benchmarks, these models struggle when given examples that are distributionally different from examples seen during ﬁne-tuning (McCoy et al., 2019).
Revised: However, despite the strong performance of this two-stage learning procedure on common benchmarks, these models struggle when given examples that are distributionally different from examples seen during ﬁne-tuning (McCoy et al., 2019).

Original: Their learned behavior often relies on simple (at times spurious) patterns to offer shortcuts to an answer, rather than robust, structured reasoning that effectively fuses the explicit information provided by the context and implicit external knowledge (Marcus, 2018).
Revised: Their learned behavior often relies on simple (at times spurious) patterns to offer shortcuts to an answer, rather than robust, structured reasoning that effectively fuses the explicit information provided by the context and implicit external knowledge (Marcus, 2018).

Original: On the other hand, massive knowledge graphs (KG), such as Freebase (Bollacker et al., 2008), Wikidata (Vrandeˇci´c & Kr¨otzsch, 2014), ConceptNet (Speer et al., 2017), and Yago (Suchanek et al., 2007) capture such external knowledge explicitly using triplets that capture relationships between entities.
Revised: On the other hand, massive knowledge graphs (KG), such as Freebase (Bollacker et al., 2008), Wikidata (Vrandeˇci´c & Kr¨otzsch, 2014), ConceptNet (Speer et al., 2017), and Yago (Suchanek et al., 2007) capture such external knowledge explicitly using triplets that capture relationships between entities.

Original: Previous research has demonstrated the signiﬁcant role KGs can play in structured reasoning and query answering (Ren et al., 2020; Ren & Leskovec, 2020).
Revised: Previous research has demonstrated the signiﬁcant role KGs can play in structured reasoning and query answering (Ren et al., 2020; Ren & Leskovec, 2020).

Original: However, extending these reasoning advantages to general QA (where questions and answers are expressed in natural language and not easily mapped to strict logical queries) requires ﬁnding the right integration of knowledge from the KG with the information and constraints provided by the QA example.
Revised: However, extending these reasoning advantages to general QA (where questions and answers are expressed in natural language and not easily mapped to strict logical queries) requires ﬁnding the right integration of knowledge from the KG with the information and constraints provided by the QA example.

Original: Prior methods propose various ways to leverage both modalities ( i.e. , expressive large language models and structured KGs) for improved reasoning (Mihaylov & Frank, 2018;
Revised: Prior methods propose various ways to leverage both modalities ( i.e. , expressive large language models and structured KGs) for improved reasoning (Mihaylov & Frank, 2018;

Original: Lin et al., 2019; Feng et al., 2020).
Revised: Lin et al., 2019; Feng et al., 2020).

Original: However, these methods typically fuse the two modalities in a shallow and non-interactive manner, encoding both separately and fusing them at the output for a prediction, or using one to augmentthe input of the other. Consequently, previous methods demonstrate restricted capacity to exchange
Revised: However, these methods typically fuse the two modalities in a shallow and non-interactive manner, encoding both separately and fusing them at the output for a prediction, or using one to augment

Original: [Figure]
Revised: [Figure]

Original: painting
Revised: painting

Original: A t L o c a t i o n roundbrush hairbrush
Revised: A t L o c a t i o n roundbrush hairbrush

Original: R e l a t e d T o A t L o c a t i o n
Revised: R e l a t e d T o A t L o c a t i o n

Original: U s e d F
Revised: U s e d F

Original: o r
Revised: o r

Original: U s e d F
Revised: U s e d F

Original: o r
Revised: o r

Original: C h
Revised: C h

Original: o i
Revised: o i

Original: c e E n t
Revised: c e E n t

Original: i t y Q
Revised: i t y Q

Original: u e s t
Revised: u e s t

Original: i o n E n t
Revised: i o n E n t

Original: i t y
Revised: i t y

Original: [Figure]
Revised: [Figure]

Original: GNN Layer ℎ !
Revised: GNN Layer ℎ !

Original: (#$!)
Revised: (#$!)

Original: ℎ &(#$!)
Revised: ℎ &(#$!)

Original: ℎ ’()(#$!) ··· ℎ !(#) ℎ &(#) $ℎ ’()(#) ··· ℎ ’()(#) 𝑒 ’()(#$!)
Revised: ℎ ’()(#$!) ··· ℎ !(#) ℎ &(#) $ℎ ’()(#) ··· ℎ ’()(#) 𝑒 ’()(#$!)

Original: 𝑒 !
Revised: 𝑒 !

Original: (#$!)
Revised: (#$!)

Original: 𝑒 *(#$!) ··· ̃𝑒 ’()(#) 𝑒 !(#) 𝑒 *(#) ··· 𝑒 ’()(#)
Revised: 𝑒 *(#$!) ··· ̃𝑒 ’()(#) 𝑒 !(#) 𝑒 *(#) ··· 𝑒 ’()(#)

Original: LM Layer
Revised: LM Layer

Original: GNN Layer ℎ !
Revised: GNN Layer ℎ !

Original: (#+!)
Revised: (#+!)

Original: ℎ &(#+!)
Revised: ℎ &(#+!)

Original: $ℎ ’()(#+!) ··· ℎ ’()(#+!)
Revised: $ℎ ’()(#+!) ··· ℎ ’()(#+!)

Original: ̃𝑒 ’()(#+!)
Revised: ̃𝑒 ’()(#+!)

Original: 𝑒 !
Revised: 𝑒 !

Original: (#+!)
Revised: (#+!)

Original: 𝑒 *(#+!) ··· 𝑒 ’()(#+!)
Revised: 𝑒 *(#+!) ··· 𝑒 ’()(#+!)

Original: [Figure]
Revised: [Figure]

Original: n
Revised: n

Original: [Figure]
Revised: [Figure]

Original: e
Revised: e

Original: [Figure]
Revised: [Figure]

Original: e l e c
Revised: e l e c

Original: [Figure]
Revised: [Figure]

Original: i o n
Revised: i o n

Original: [Figure]
Revised: [Figure]

Original: ⠇
Revised: ⠇

Original: [Figure]
Revised: [Figure]

Original: be updated through LM layers and the KG is processed using a GNN, simulating reasoning over its knowledge.
Revised: be updated through LM layers and the KG is processed using a GNN, simulating reasoning over its knowledge.

Original: In each layer, after each modality’s representation is updated, the representations of the interaction token and node are pulled, concatenated, and passed through a modality interaction (MInt) unit to mix their representations.
Revised: In each layer, after each modality’s representation is updated, the representations of the interaction token and node are pulled, concatenated, and passed through a modality interaction (MInt) unit to mix their representations.

Original: In subsequent layers, the mixed information from the interaction elements mixes with their respective modalities, allowing knowledge from the KG to affect the representations of individual tokens, and context from language to affect ﬁne-grained entity knowledge representations in the GNN useful information between the two modalities.
Revised: In subsequent layers, the mixed information from the interaction elements mixes with their respective modalities, allowing knowledge from the KG to affect the representations of individual tokens, and context from language to affect ﬁne-grained entity knowledge representations in the GNN. the input of the other. Consequently, previous methods demonstrate restricted capacity to exchange useful information between the two modalities.

Original: It remains an open question how to effectively fuse the KG and LM representations in a truly uniﬁed manner, where the two representations can interact in a non-shallow way to simulate structured, situational reasoning.
Revised: It remains an open question how to effectively fuse the KG and LM representations in a truly uniﬁed manner, where the two representations can interact in a non-shallow way to simulate structured, situational reasoning.

Original: In this work, we present G REASE LM, a new model that enables fusion and exchange of information from both the LM and KG in multiple layers of its architecture (see Figure 1).
Revised: In this work, we present G REASE LM, a new model that enables fusion and exchange of information from both the LM and KG in multiple layers of its architecture (see Figure 1).

Original: Our proposed
Revised: Our proposed

Original: G REASE LM consists of an LM that takes as input the natural language context, as well as a graph neural network (GNN) that reasons over the KG.
Revised: G REASE LM consists of an LM that takes as input the natural language context, as well as a graph neural network (GNN) that reasons over the KG.

Original: After each layer of the LM and GNN, we design an interactive scheme to bidirectionally transfer the information from each modality to the other through specially initialized interaction representations ( i.e. , interaction token for the LM; interaction node for the GNN).
Revised: After each layer of the LM and GNN, we design an interactive scheme to bidirectionally transfer the information from each modality to the other through specially initialized interaction representations ( i.e. , interaction token for the LM; interaction node for the GNN).

Original: In such a way, all the tokens in the language context receive information from the KG entities through the interaction token and the KG entities indirectly interact with the tokens through the interaction node.
Revised: In such a way, all the tokens in the language context receive information from the KG entities through the interaction token and the KG entities indirectly interact with the tokens through the interaction node.

Original: By such a deep integration across all layers, G REASE LM enables joint reasoning over both the language context and the KG entities under a uniﬁed framework agnostic to the speciﬁc language model or graph neural network, so that both modalities can be contextualized by the other.
Revised: By such a deep integration across all layers, G REASE LM enables joint reasoning over both the language context and the KG entities under a uniﬁed framework agnostic to the speciﬁc language model or graph neural network, so that both modalities can be contextualized by the other.

Original: G REASE LM demonstrates signiﬁcant performance gains across different LM architectures.
Revised: G REASE LM demonstrates signiﬁcant performance gains across different LM architectures.

Original: We perform experiments on several standard QA benchmarks: CommonsenseQA, OpenbookQA and
Revised: We perform experiments on several standard QA benchmarks: CommonsenseQA, OpenbookQA and

Original: MedQA-USMLE, which require external knowledge across different domains (commonsense reasoning and medical reasoning)
Revised: MedQA-USMLE, which require external knowledge across different domains (commonsense reasoning and medical reasoning)

Original: and use different KGs (ConceptNet and Disease Database).
Revised: and use different KGs (ConceptNet and Disease Database).

Original: Across both domains, G REASE LM outperforms comparably-sized prior QA models, including strong ﬁnetuned LM baselines (by 5.5%, 6.6%, and 1.3%, respectively) and state-of-the-art KG+LM models (by 0.9%, 1.8%, and 0.5%, respectively) on the three competitive benchmarks.
Revised: Across both domains, G REASE LM outperforms comparably-sized prior QA models, including strong ﬁnetuned LM baselines (by 5.5%, 6.6%, and 1.3%, respectively) and state-of-the-art KG+LM models (by 0.9%, 1.8%, and 0.5%, respectively) on the three competitive benchmarks.

Original: Furthermore, with the deep fusion of both modalities, G REASE LM exhibits strong performance over baselines on questions that exhibit textual nuance, such as resolving multiple constraints, negation, and hedges, and which require effective reasoning over both language context and KG.
Revised: Furthermore, with the deep fusion of both modalities, G REASE LM exhibits strong performance over baselines on ques- tions that exhibit textual nuance, such as resolving multiple constraints, negation, and hedges, and which require effective reasoning over both language context and KG.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Integrating KG information has become a popular research area for improving neural QA systems.
Revised: Integrating KG information has become a popular research area for improving neural QA systems.

Original: Some works explore using two-tower models to answer questions, where a graph representation of knowledge and language representation are fused with no interaction between them (Wang et al., 2019).
Revised: Some works explore using two-tower models to answer questions, where a graph representation of knowledge and language representation are fused with no interaction between them (Wang et al., 2019).

Original: Other works seek to use one modality to ground the other, such as using an encoded representation of a linked KG to augment the textual representation of a QA example ( e.g. , Knowledgeable
Revised: Other works seek to use one modality to ground the other, such as using an encoded representation of a linked KG to augment the textual representation of a QA example ( e.g. , Knowledgeable

Original: Reader, Mihaylov & Frank, 2018; KagNet, Lin et al., 2019; KT-NET
Revised: Reader, Mihaylov & Frank, 2018; KagNet, Lin et al., 2019; KT-NET

Original: Yang et al., 2019).
Revised: Yang et al., 2019).

Original: Others reverse the ﬂow of information and use a representation of the text ( e.g. , ﬁnal layer of LM) to provide an augmentation to a graph reasoning model over an extracted KG for the example ( e.g. , MHGRN,
Revised: Others reverse the ﬂow of information and use a representation of the text ( e.g. , ﬁnal layer of LM) to provide an augmentation to a graph reasoning model over an extracted KG for the example ( e.g. , MHGRN,

Original: Feng et al., 2020;
Revised: Feng et al., 2020;

Original: Lv et al., 2020).
Revised: Lv et al., 2020).

Original: In all of these settings, however, the interaction between both modalities is limited as information between them only ﬂows one way.
Revised: In all of these settings, however, the interaction between both modalities is limited as information between them only ﬂows one way.

Original: More recent approaches explore deeper integrations of both modalities.
Revised: More recent approaches explore deeper integrations of both modalities.

Original: Certain approaches learn to access implicit knowledge encoded in LMs (Bosselut et al., 2019; Petroni et al., 2019; Hwang et al., 2021) by training on structured KG data, and then use the LM to generate local KGs that can be used for QA (Wang et al., 2020; Bosselut et al., 2021).
Revised: Certain approaches learn to access implicit knowledge encoded in LMs (Bosselut et al., 2019; Petroni et al., 2019; Hwang et al., 2021) by training on structured KG data, and then use the LM to generate local KGs that can be used for QA (Wang et al., 2020; Bosselut et al., 2021).

Original: However, these approaches discard the static
Revised: However, these approaches discard the static

Original: KG once they train the LM on its facts, losing important structure that can guide reasoning.
Revised: KG once they train the LM on its facts, losing important structure that can guide reasoning.

Original: More recently, QA-GNN (Yasunaga et al., 2021) proposed to jointly update the LM and GNN representations via message passing.
Revised: More recently, QA-GNN (Yasunaga et al., 2021) proposed to jointly update the LM and GNN representations via message passing.

Original: However, they use a single pooled representation of the LM to seed the textual component of this joint structure, limiting the updates that can be made to the textual representation.
Revised: However, they use a single pooled representation of the LM to seed the textual component of this joint structure, limiting the updates that can be made to the textual representation.

Original: In contrast to prior works, we propose to make individual token representations in the LM and node representations in the GNN mix for multiple layers, enabling representations of both modalities to reﬂect particularities of the other (e.g., knowledge grounds language; language nuances speciﬁes which knowledge is important).
Revised: In contrast to prior works, we propose to make individual token representations in the LM and node representations in the GNN mix for multiple layers, enabling representations of both modalities to reﬂect particularities of the other (e.g., knowledge grounds language; language nuances speciﬁes which knowledge is important).

Original: Simultaneously, we retain the individual structure of both modalities, which we demonstrate improves QA performance substantially (§5).
Revised: Simultaneously, we retain the individual structure of both modalities, which we demonstrate improves QA performance substantially (§5).

Revised: Additionally, some works explore integrating KGs graphs with LMs models in the pretraining stage.

Revised: However, much like for QA, the modality interaction is typically limited to knowledge feeding language (Zhang et al., 2019; Shen et al., 2020; Yu et al., 2020), rather than designing interactions across multiple layers.

Revised: Sun et al.

Revised: (2020)’s work is perhaps most similar, but they do not use the same interaction bottleneck, requiring high-precision entity mention spans for linking, and they limit expressivity through shared modality parameters for the LM and KG.

Original:  P ROPOSED A PPROACH : G REASE LM
Revised:  P ROPOSED A PPROACH : G REASE LM

Original: In this work, we augment large-scale language models (Devlin et al., 2019;
Revised: In this work, we augment large-scale language models (Devlin et al., 2019;

Original: Liu et al., 2019; Lan et al., 2020; Liu et al., 2020) with graph reasoning modules over KGs.
Revised: Liu et al., 2019; Lan et al., 2020; Liu et al., 2020) with graph reasoning modules over KGs.

Original: Our method, G REASE LM (depicted in Figure 1), consists of two stacked components: (1) a set of unimodal LM layers which learn an initial representation of the input tokens, and (2) a set of upper cross-modal G REASE LM layers which learn to jointly represent the language sequence and linked knowledge graph, allowing textual representations formed from the underlying LM layers and a graph representation of the KG to mix with one another.
Revised: Our method, G REASE LM (depicted in Figure 1), consists of two stacked components: (1) a set of unimodal LM layers which learn an initial representation of the input tokens, and (2) a set of upper cross-modal G REASE LM layers which learn to jointly represent the language sequence and linked knowledge graph, allowing textual representations formed from the underlying LM layers and a graph representation of the KG to mix with one another.

Original: We denote the number of LM layers as N , and the number of G REASE LM layers as M .
Revised: We denote the number of LM layers as N , and the number of G REASE LM layers as M .

Original: The total number of layers in our model is N + M .
Revised: The total number of layers in our model is N + M .

Original: Notation In the task of multiple choice question answering (MCQA) , a generic MCQA-type dataset consists of examples with a context paragraph c , a question q and a candidate answer set A , all expressed in text.
Revised: Notation. In the task of multiple choice question answering (MCQA) , a generic MCQA-type dataset consists of examples with a context paragraph c , a question q and a candidate answer set A , all expressed in text.

Original: In this work, we also assume access to an external knowledge graph (KG) G that provides background knowledge that is relevant to the content of the multiple choice questions.
Revised: In this work, we also assume access to an external knowledge graph (KG) G that provides background knowledge that is relevant to the content of the multiple choice questions.

Original: Given a QA example ( c, q, A ) , and the KG G as input, our goal is to identify which answer a ∈ A is correct.
Revised: Given a QA example ( c, q, A ) , and the KG G as input, our goal is to identify which answer a ∈ A is correct.

Original: Without loss of generality, when an operation is applied to an arbitrary answer, we refer to that answer as a .
Revised: Without loss of generality, when an operation is applied to an arbitrary answer, we refer to that answer as a .

Original: We denote a sequence of tokens in natural language as { w 1 , . . .
Revised: We denote a sequence of tokens in natural language as { w 1 , . . .

Original: , w T } , where T is the total number of tokens, and the representation of a token w t from the (cid:96) -th layer of the model as h ( (cid:96) ) t .
Revised: , w T } , where T is the total number of tokens, and the representation of a token w t from the (cid:96) -th layer of the model as h ( (cid:96) ) t .

Original: We denote a set of nodes as { e 1 , . . .
Revised: We denote a set of nodes as { e 1 , . . .

Original: , e J } , where J is the total number of nodes, and the representation of a node e j in the (cid:96) -th layer of the model as e ( (cid:96) )
Revised: , e J } , where J is the total number of nodes, and the representation of a node e j in the (cid:96) -th layer of the model as e ( (cid:96) )

Original: j .
Revised: j .

Original: 3. I NPUT REPRESENTATION
Revised: 3. I NPUT REPRESENTATION

Original: We concatenate our context paragraph c , question q , and candidate answer a with separator tokens to get our model input [ c ; q ; a ] and tokenize the combined sequence into { w 1 , . . .
Revised: We concatenate our context paragraph c , question q , and candidate answer a with separator tokens to get our model input [ c ; q ; a ] and tokenize the combined sequence into { w 1 , . . .

Original: , w T } .
Revised: , w T } .

Original: Second, we use the input sequence to retrieve a subgraph of the KG G (denoted G sub ), which provides knowledge from the KG that is relevant to this QA example.
Revised: Second, we use the input sequence to retrieve a subgraph of the KG G (denoted G sub ), which provides knowledge from the KG that is relevant to this QA example.

Original: We denote the set of nodes in G sub as { e 1 , . . .
Revised: We denote the set of nodes in G sub as { e 1 , . . .

Original: , e J } .
Revised: , e J } .

Original: KG retrieval.
Revised: KG Retrieval.

Original: Given each QA context, we follow the procedure from Yasunaga et al.
Revised: Given each QA context, we follow the procedure from Yasunaga et al.

Original: (2021) to retrieve the subgraph G sub from G .
Revised: (2021) to retrieve the subgraph G sub from G .

Original: First, we perform entity linking to G to retrieve an initial set of nodes V linked . Second, we add any bridge entities that are in a 2-hop path between any pair of linked entities in V linked to get the ﬁnal set of retrieved entities V sub . We then retrieved all the edges that connect any two nodes in V sub , forming the retrieved subgraph G sub .
Revised: We describe this procedure in Appendix A.1.

Original: Each node  is assigned a type according to whether its corresponding entity was linked from the context c , question q , answer a , or from a bridge path.
Revised: Each node in G sub is assigned a type based on whether its corresponding entity was linked from the context c , question q , answer a , or as a neighbor to these nodes.

Original: In the remaining parts of the paper, we usethe term “KG” to refer to G sub .
Revised: In the rest of the paper, we use “KG” to refer to G sub .

Original: Interaction Bottlenecks.
Revised: Interaction Bottlenecks.

Original: In the cross-modal G REASE LM layers, information is fused between both modalities, for which we deﬁne a special interaction token w int and a special interaction node e int whose representations serve as the bottlenecks through which the two modalities interact (§3.3).
Revised: In the cross-modal G REASE LM layers, information is fused between both modalities, for which we deﬁne a special interaction token w int and a special interaction node e int whose representations serve as the bottlenecks through which the two modalities interact (§3.3).

Original: We prepend w int to the token sequence and connect e int to all the linked nodes V linked in G sub .
Revised: We prepend w int to the token sequence and connect e int to all the linked nodes V linked in G sub .

Original: 3. L ANGUAGE P RE - ENCODING
Revised: 3. L ANGUAGE P RE - ENCODING

Original: In the unimodal encoding component, given the sequence of tokens { w int , w 1 , . . .
Revised: In the unimodal encoding component, given the sequence of tokens { w int , w 1 , . . .

Original: , w T } , we ﬁrst sum the token, segment, and positional embeddings for each token to compute its (cid:96) =0 input representation { h (0) int , h (0)1 , . . .
Revised: , w T } , we ﬁrst sum the token, segment, and positional embeddings for each token to compute its (cid:96) =0 input representation { h (0) int , h (0)1 , . . .

Original: , h (0) T } , and then compute an output representation for each layer (cid:96) :
Revised: , h (0) T } , and then compute an output representation for each layer (cid:96) :

Original: { h ( (cid:96) ) int , h ( (cid:96) ) 1 , . .
Revised: { h ( (cid:96) ) int , h ( (cid:96) ) 1 , . .

Original: , h ( (cid:96) ) T } =
Revised: , h ( (cid:96) ) T } =

Original: LM-Layer ( { h ( (cid:96) − 1) int , h ( (cid:96) − 1), . .
Revised: LM-Layer ( { h ( (cid:96) − 1) int , h ( [Equation]

Original: , h ( (cid:96) − 1) T } ) (1) for (cid:96) = 1 , . . .
Revised: [Equation] for (cid:96) [Equation]

Original: , N where LM-Layer( · ) is a single LM encoder layer, whose parameters are initialized using a pretrained model (§4.1).
Revised: N where LM-Layer( · ) is a single LM encoder layer, whose parameters are initialized using a pretrained model (§4.1).

Original: We refer readers to Vaswani et al.
Revised: We refer readers to Vaswani et al.

Original: (2017) for technical details of these layers.
Revised: (2017) for technical details of these layers.

Original: 3. G REASE LM
Revised: 3. G REASE LM

Original: G REASE LM uses a cross-modal fusion component to inject information from the KG into language representations and information from language into KG representations.
Revised: G REASE LM uses a cross-modal fusion component to inject information from the KG into language representations and information from language into KG representations.

Original: The G REASE LM layer is designed to separately encode information from both modalities, and fuse their representations using the bottleneck of the special interaction token and node.
Revised: The G REASE LM layer is designed to separately encode information from both modalities, and fuse their representations using the bottleneck of the special interaction token and node.

Original: It is comprised of three components: (1) a transformer LM encoder block which continues to encode the language context, (2) a GNN layer that reasons over KG entities and relations, and (3) a modality interaction layer that takes the unimodal representations of the interaction token and interaction node and exchanges information through them.
Revised: It is comprised of three components: (1) a transformer LM encoder block which continues to encode the language context, (2) a GNN layer that reasons over KG entities and relations, and (3) a modality interaction layer that takes the unimodal representations of the interaction token and interaction node and exchanges information through them.

Original: We discuss these three components below.
Revised: We discuss these three components below.

Original: Language Representation.
Revised: Language Representation.

Original: In the (cid:96) -th
Revised: In the (cid:96) -th

Original: G REASE LM layer, the input token embeddings { h ( N + (cid:96) − 1) int , h ( N + (cid:96) − 1), . .
Revised: G REASE LM layer, the input token embeddings { h ( N + (cid:96) − 1) int , h ( N + (cid:96) − 1), . .

Original: , h ( N + (cid:96) − 1) T } are fed into additional transformer LM encoder blocks that continue to encode the textual context based on the LM’s pretrained representations: { 
Revised: , h ( N + (cid:96) − 1) T } are fed into additional transformer LM encoder blocks that continue to encode the textual context based on the LM’s pretrained representations: { ˜

Original: [Equation]
Revised: [Equation]

Original: ( N + (cid:96) ) int , ˜ h

Original: ( N +(cid:96) ) [Equation] [Equation] N
Revised: N +

Original: [Equation]
Revised: [Equation]

Original: T

Original: [Equation] = LM-Layer ( { [Equation] N
Revised: int

Original: [Equation]
Revised: [Equation]

Original: 1) int , h ( N + (cid:96)

Original: [Equation]
Revised: [Equation]

Original: , h ( N + (cid:96)

Original: [Equation]

Original: 1) T } )(2) for (cid:96) = 1 , . . .
Revised: ) for (cid:96) = 1 , . . .

Original: , M where ˜ h corresponds to pre-fused embeddings of the language modality.
Revised: , M where ˜ h corresponds to pre-fused embeddings of the language modality.

Original: As we will discuss below, because h N + (cid:96) − 1 int will encode information received from the knowledge graph representation, these late language encoding layers will also allow the token representations to mix with KG knowledge.
Revised: As we will discuss below, because h N + (cid:96) − 1 int will encode information received from the knowledge graph representation, these late language encoding layers will also allow the token representations to mix with KG knowledge.

Original: Graph Representation.
Revised: Graph Representation.

Original: The G REASE LM layers also encode a representation of the local KG G sub linked from the QA example.
Revised: The G REASE LM layers also encode a representation of the local KG G sub linked from the QA example.

Original: To represent the graph, we ﬁrst compute initial node embeddings { e (0)1 , . . .
Revised: To represent the graph, we ﬁrst compute initial node embeddings { e (0)1 , . . .

Original: , e (0) J } for the retrieved entities using pretrained KG embeddings for these nodes (§4.1).
Revised: , e (0) J } for the retrieved entities using pretrained KG embeddings for these nodes (§4.1).

Original: The initial embedding of the interaction node e 0 int is initialized randomly.
Revised: The initial embedding of the interaction node e 0 int is initialized randomly.

Original: Then, in each layer of the GNN, the current representation of the node embeddings { e [Equation] int , e ( (cid:96) [Equation]
Revised: Then, in each layer of the GNN, the current representation of the node embeddings { e ( (cid:96) − 1) int , e ( (cid:96) − 1), . .

Original: , e

Original: [Equation] (cid:96) − [Equation] ) J } is fed into the layer to perform a round of information propagation between nodes in the graph and yield pre-fused node embeddings for each entity:
Revised: , e ( (cid:96) − 1) J } is fed into the layer to perform a round of information propagation between nodes in the graph and yield pre-fused node embeddings for each entity:

Original: [Equation]
Revised: [Equation]

Original: where GNN corresponds to a variant of graph attention networks (Veliˇckovi´c et al., 2018) that is a simpliﬁcation of the method of Yasunaga et al.
Revised: where GNN corresponds to a variant of graph attention networks (Veliˇckovi´c et al., 2018) that is a simpliﬁcation of the method of Yasunaga et al.

Original: The GNN computes node representations 
Revised: The GNN computes node representations ˜ e

Original: [Equation]
Revised: ( (cid:96) )

Original:  for each node e j ∈ { e 1 , . ..
Revised: j for each node e j ∈ { e 1 , . .

Original: , e J } via message passing between neighbors on the graph.
Revised: , e J } via message passing between neighbors on the graph.

Original: [Equation]
Revised: [Equation]

Original: where N e j represents the neighborhood of an arbitrary node e j , m sj denotes the message one of its neighbors e s passes to e j , α sj is an attention weight that scales the message m sj , and f n is a 2-layer
Revised: where N e j represents the neighborhood of an arbitrary node e j , m sj denotes the message one of its neighbors e s passes to e j , α sj is an attention weight that scales the message m sj , and f n is a 2-layer

Original: MLP.
Revised: MLP.

Original: The messages m sj between nodes allow entity information from a node to affect the model’s representation of its neighbors, and are computed in the following manner:
Revised: The messages m sj between nodes allow entity information from a node to affect the model’s representation of its neighbors, and are computed in the following manner:

Original: [Equation]
Revised: [Equation]

Original: where u s , u j are node type embeddings, ˜ r sj is a relation embedding for the relation connecting e s and e j , f r is a 2-layer MLP, and f m is a linear transformation.
Revised: where u s , u j are node type embeddings, ˜ r sj is a relation embedding for the relation connecting e s and e j , f r is a 2-layer MLP, and f m is a linear transformation.

Original: The attention weights α sj scale the contribution of each neighbor’s message by its importance, and are computed as follows:
Revised: The attention weights α sj scale the contribution of each neighbor’s message by its importance, and are computed as follows:

Original: [Equation]
Revised: [Equation]

Original: where f q and f k are linear transformations and u s , u j , r sj are deﬁned the same as above.
Revised: where f q and f k are linear transformations and u s , u j , r sj are deﬁned the same as above.

Original: As discussed in the following paragraph, message passing between the interaction node e int and the nodes from the retrieved subgraph will allow information from text that e int receives from w int to propagate to the other nodes in the graph.
Revised: As discussed in the following paragraph, message passing between the interaction node e int and the nodes from the retrieved subgraph will allow information from text that e int receives from w int to propagate to the other nodes in the graph.

Original: Modality Interaction.
Revised: Modality Interaction.

Original: Finally, after using a transformer LM layer and a GNN layer to update token embeddings and node embeddings respectively, we use a modality interaction layer (MInt) to let the two modalities fuse information through the bottleneck of the interaction token w int and the interaction node e int .
Revised: Finally, after using a transformer LM layer and a GNN layer to update token embeddings and node embeddings respectively, we use a modality interaction layer (MInt) to let the two modalities fuse information through the bottleneck of the interaction token w int and the interaction node e int .

Original: We concatenate the pre-fused embeddings of the interaction token
Revised: We concatenate the pre-fused embeddings of the interaction token

Original: ˜ h ( i ) int and interaction node ˜ e ( i ) int , pass the joint representation through a mixing operation (MInt), and then split the output post-fused embeddings into h ( i ) int and e ( i ) int :
Revised: ˜ h ( i ) int and interaction node ˜ e ( i ) int , pass the joint representation through a mixing operation (MInt), and then split the output post-fused embeddings into h ( i ) int and e ( i ) int :

Original: [Equation]
Revised: [Equation]

Original: We use a two-layer MLP as our MInt operation, though other fusion operators could be used to mix the representation.
Revised: We use a two-layer MLP as our MInt operation, though other fusion operators could be used to mix the representation.

Original: All the tokens other than the interaction token w int and all the nodes other than the interaction node e int are not involved in the modality interaction process: w ( (cid:96) )
Revised: All the tokens other than the interaction token w int and all the nodes other than the interaction node e int are not involved in the modality interaction process: w ( (cid:96) )

Original: =
Revised: =

Original: ˜ w ( (cid:96) ) for w ∈ { w 1 , . . .
Revised: ˜ w ( (cid:96) ) for w ∈ { w 1 , . . .

Original: , w T } and e ( (cid:96) )
Revised: , w T } and e ( (cid:96) )

Original: =
Revised: =

Original: ˜
Revised: ˜

Original: e ( (cid:96) ) for e ∈ { e 1 , . .
Revised: e ( (cid:96) ) for e ∈ { e 1 , . .

Original: , e J } .
Revised: , e J } .

Original: However, they receive information from the interaction representations h ( (cid:96) ) int and e ( (cid:96) ) int in the next layers of their respective modal propagation ( i.e. ,
Revised: However, they receive information from the interaction representations h ( (cid:96) ) int and e ( (cid:96) ) int in the next layers of their respective modal propagation ( i.e. ,

Original: Eqs.
Revised: Eqs.

Original: Consequently, across multiple G REASE LM layers, information propagates between both modalities (see Fig.
Revised: Consequently, across multiple G REASE LM layers, information propagates between both modalities (see Fig.

Original: 1 for visual depiction), grounding language representations to KG knowledge, and knowledge representations to contextual constraints.
Revised: 1 for visual depiction), grounding language representations to KG knowledge, and knowledge representations to contextual constraints.

Original: Learning & Inference For the MCQA task, given a question q and an answer a from all the candidates A , we compute the probability of a being the correct answer as p ( a | q, c ) ∝ exp( MLP ( h ( N + M ) int , e ( M ) int , g )) , where g denotes attention-based pooling of { e ( M ) j | e j ∈ { e 1 , . . .
Revised: Learning & Inference. For the MCQA task, given a question q and an answer a from all the candidates A , we compute the probability of a being the correct answer as p ( a | q, c ) ∝ exp( MLP ( h ( N + M ) int , e ( M ) int , g )) , where g denotes attention-based pooling of { e ( M ) j | e j ∈ { e 1 , . . .

Original: , e J }} using h ( N + M ) int as a query.
Revised: , e J }} using h ( N + M ) int as a query.

Original: We optimize the whole model end-to-end using the cross entropy loss.
Revised: We optimize the whole model end-to-end using the cross entropy loss.

Original: At inference time, we predict the most plausible answer as arg max a ∈A p ( a | q, c ) .
Revised: At inference time, we predict the most plausible answer as arg max a ∈A p ( a | q, c ) .

Original:  E XPERIMENTAL S ETUP
Revised:  E XPERIMENTAL S ETUP

Original: We evaluate G REASE LM on three diverse multiple-choice question answering datasets across two domains: CommonsenseQA (Talmor et al., 2019) and OpenBookQA (Mihaylov et al., 2018) as commonsense reasoning benchmarks, and MedQA-USMLE (Jin et al., 2021) as a clinical QA task. 
Revised: We evaluate G REASE LM on three diverse multiple-choice question answering datasets across two domains: CommonsenseQA (Talmor et al., 2019) and OpenBookQA (Mihaylov et al., 2018) as commonsense reasoning benchmarks, and MedQA-USMLE (Jin et al., 2021) as a clinical QA task. [Table] A) a [Table]

Original: CommonsenseQA is a5-way multiple-choice question answering dataset of 12,102 questions that require background commonsense knowledge beyond surface language understanding. We perform our experiments using the in-house data split of Lin et al. (2019) to compare to baseline methods.
Revised: cafeteria (C) a

Original: [Table]
Revised: [Table]

Revised: at a

Original: [Table]
Revised: [Table]

Original:  calvin 
Revised: (D) a calvin klein cotton hat

Original: [Table]
Revised: [Table]

Original: A 57-year-old man presents to his primary care physician with a 2-month history of right upper and lower extremity weakness.
Revised: A 57-year-old man presents to his primary care physician with a 2-month history of right upper and lower extremity weakness.

Original: He noticed the weakness when he started falling far more frequently while running errands.
Revised: He noticed the weakness when he started falling far more frequently while running errands.

Original: Since then, he has had increasing difﬁculty with walking and lifting objects.
Revised: Since then, he has had increasing difﬁculty with walking and lifting objects.

Original: His past medical history is signiﬁcant only for well-controlled hypertension, but he says that some members of his family have had musculoskeletal problems.
Revised: His past medical history is signiﬁcant only for well-controlled hypertension, but he says that some members of his family have had musculoskeletal problems.

Original: His right upper extremity shows forearm atrophy and depressed reﬂexes while his right lower extremity is hypertonic with a positive Babinski sign.
Revised: His right upper extremity shows forearm atrophy and depressed reﬂexes while his right lower extremity is hypertonic with a positive Babinski sign.

Original: Which of the following is most likely associated with the cause of this patients symptoms?
Revised: Which of the following is most likely associated with the cause of this patients symptoms?

Original: [Table] [Figure] 
Revised: [Figure] [Table]

Original: [Table]
Revised: CommonsenseQA is a 5-way multiple-choice question answering dataset of 12,102 questions that require background commonsense knowledge beyond surface language understanding. We perform our experiments using the in-house data split of Lin et al. (2019) to compare to baseline methods.

Original: OpenbookQA is a 4-way multiple-choice question answering dataset that tests elementary scientiﬁc knowledge.
Revised: OpenbookQA is a 4-way multiple-choice question answering dataset that tests elementary scientiﬁc knowledge.

Original: It contains 5,957 questions along with an open book of scientiﬁc facts.
Revised: It contains 5,957 questions along with an open book of scientiﬁc facts.

Original: We use the ofﬁcial data splits from Mihaylov & Frank (2018).
Revised: We use the ofﬁcial data splits from Mihaylov & Frank (2018).

Original: MedQA-USMLE is a 4-way multiple-choice question answering dataset, which requires biomedical and clinical knowledge.
Revised: MedQA-USMLE is a 4-way multiple-choice question answering dataset, which requires biomedical and clinical knowledge.

Original: The questions are originally from practice tests for the United States
Revised: The questions are originally from practice tests for the United States

Original: Medical License Exams (USMLE).
Revised: Medical License Exams (USMLE).

Original: The dataset contains 12,723 questions.
Revised: The dataset contains 12,723 questions.

Original: We use the original data splits from Jin et al.
Revised: We use the original data splits from Jin et al.

Original: 4. I MPLEMENTATION & TRAINING DETAILS
Revised: 4. I MPLEMENTATION & TRAINING DETAILS

Original: Language Models.
Revised: Language Models.

Original: We seed G REASE LM with RoBERTa-Large (Liu et al., 2019) for our experiments on CommonsenseQA, AristoRoBERTa (Clark et al., 2019) for our experiments on OpenbookQA, and SapBERT (Liu et al., 2020) for our experiments on MedQA-USMLE, demonstrating
Revised: We seed G REASE LM with RoBERTa-Large (Liu et al., 2019) for our experiments on CommonsenseQA, AristoRoBERTa (Clark et al., 2019) for our experiments on OpenbookQA, and SapBERT (Liu et al., 2020) for our experiments on MedQA-USMLE, demonstrating

Original: G REASE LM’s generality with respect to language model initializations.
Revised: G REASE LM’s generality with respect to language model initializations.

Original: Hyperparameters for training these models can be found in Appendix Table 8.
Revised: Hyperparameters for training these models can be found in Appendix Table 8.

Original: Knowledge Graphs.
Revised: Knowledge Graphs.

Original: We use ConceptNet (Speer et al., 2017), a general-domain knowledge graph, as our external knowledge source G for both CommonsenseQA and OpenbookQA.
Revised: We use ConceptNet (Speer et al., 2017), a general-domain knowledge graph, as our external knowledge source G for both CommonsenseQA and OpenbookQA.

Original: It has 799, nodes and 2,487,810 edges in total.
Revised: It has 799, nodes and 2,487,810 edges in total.

Original: To compute initial node embeddings (§3.3) for entities retrieved from ConceptNet, we follow the method of MHGRN (Feng et al., 2020).

Original: We convert knowledge triples in the KG into sentences using pre-deﬁned templates for each relation.

Original: Then, these sentences are fed into a BERT-large LM to compute embeddings for each sentence.

Original: Finally, for all sentences containing an entity, we extract all token representations of the entity’s mention spans in these sentences, mean pool over these representations and project this mean-pooled representation.

Original: For MedQA-USMLE, we use a self-constructed knowledge graph that integrates the Disease Database portion of the Uniﬁed Medical Language System (UMLS; Bodenreider, 2004) and DrugBank (Wishart et al., 2018).
Revised: For MedQA-USMLE, we use a self-constructed knowledge graph that integrates the Disease Database portion of the Uniﬁed Medical Language System (UMLS; Bodenreider, 2004) and DrugBank (Wishart et al., 2018).

Original: The knowledge graph contains 9,958 nodes and 44,561 edges.
Revised: The knowledge graph contains 9, nodes and 44,561 edges.

Original: Node embeddings are initialized using the pooled token output embeddings of the entity name from the

Original: SapBERT model (described in §4.2; Liu et al., 2020). Additional  hyperparameters for preprocessing these KGs can be found in Appendix Table 8.
Revised: Additional information about node initialization and hyperparameters for preprocessing these KGs can be found in Appendix A.2.

Original: 4. B ASELINE METHODS
Revised: 4. B ASELINE METHODS

Original: Fine-tuned LMs.
Revised: Fine-tuned LMs.

Original: To study the effect of using KGs as external knowledge sources, we compare our method with vanilla ﬁne-tuned LMs, which are knowledge-agnostic.
Revised: To study the effect of using KGs as external knowledge sources, we compare our method with vanilla ﬁne-tuned LMs, which are knowledge-agnostic.

Original: We ﬁne-tune RoBERTa-
Revised: We ﬁne-tune RoBERTaLarge (Liu et al., 2019) for CommonsenseQA , and AristoRoBERTa 1 (Clark et al., 2019) for OpenBookQA . For MedQA-USMLE , we use a state-of-the-art biomedical language model, SapBERT (Liu

Original: As the ofﬁcial test is hidden, here we report the in-house Dev (IHdev) and Test (IHtest) accuracy, following the data split of Lin et al.
Revised: As the ofﬁcial test is hidden, here we report the in-house Dev (IHdev) and Test (IHtest) accuracy, following the data split of Lin et al.

Original: Experiments are controlled using same seed LM.
Revised: Experiments are controlled using same seed LM.

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 3B) are 30x and 8x larger than our model.
Revised: 3B) are 30x and 8x larger than our model.

Original: [Table]
Revised: [Table]

Original: Large (Liu et al., 2019) for CommonsenseQA , and AristoRoBERTa 1 (Clark et al., 2019) for OpenBookQA . For MedQA-USMLE , we use a state-of-the-art biomedical language model, SapBERT (Liu et al., 2020), which is an augmentation of PubmedBERT (Gu et al., 2020) that is trained with entity disambiguation objectives to allow the model to better understand entity knowledge.
Revised: et al., 2020), which is an augmentation of PubmedBERT (Gu et al., 2020) that is trained with entity disambiguation objectives to allow the model to better understand entity knowledge.

Original: Existing LM+KG models.
Revised: LM+KG models.

Original: We also evaluate G REASE LM’s ability to exploit its knowledge graph augmentation by comparing with existing LM+KG methods, which incorporate the KGs in different ways compared to G REASE LM: (1) Relation Network (RN) (Santoro et al., 2017), (2) RGCN (Schlichtkrull et al., 2018), (3) GconAttn (Wang et al., 2019),
Revised: We also evaluate G REASE LM’s ability to exploit its knowledge graph augmentation by comparing with existing LM+KG methods: (1) Relation Network (RN) (Santoro et al., 2017), (2) RGCN (Schlichtkrull et al., 2018), (3) GconAttn (Wang et al., 2019),

Original: (4) KagNet (Lin et al., 2019), (5) 
Revised: (4) KagNet (Lin et al., 2019), (5) MHGRN

Original: MHGRN (Feng et al., 2020), and (6) QA-GNN (Yasunaga et al., 2021).
Revised: (Feng et al., 2020), and (6) QA-GNN (Yasunaga et al., 2021).

Original: QA-GNN is the existing top-performing model under this LM+KG paradigm.
Revised: QA-GNN is the existing top-performing model under this LM+KG paradigm.

Original: The key difference between G REASE LM and these baseline methods is that they do not fuse the representations of both modalities across multiple interaction layers, allowing the representation of both modalities to affect the other (§3.3).
Revised: The key difference between G REASE LM and these baseline methods is that they do not fuse the representations of both modalities across multiple interaction layers, allowing the representation of both modalities to affect the other (§3.3).

Original: For fair comparison, we use the same LM in all the baselines as in our model.
Revised: For fair comparison, we use the same LM in all the baselines as in our model.

Original:  E XPERIMENT R ESULTS
Revised:  E XPERIMENT R ESULTS

Original: Our results in Tables 2 and 3 demonstrate a consistent improvement on the CommonsenseQA and
Revised: Our results in Tables 2 and 3 demonstrate a consistent improvement on the CommonsenseQA and

Original: OpenbookQA datasets.
Revised: OpenbookQA datasets.

Original: On CommonsenseQA, our model’s test performance improves by 5.5% over ﬁne-tuned LMs and 0.9% over existing LM+KG models.
Revised: On CommonsenseQA, our model’s test performance improves by 5.5% over ﬁne-tuned LMs and 0.9% over existing LM+KG models.

Original: On OpenbookQA, these improvements are magniﬁed, with 6.2% over raw LMs, and 1.8% over the prior best LM+KG system, QA-GNN.
Revised: On OpenbookQA, these improvements are magniﬁed, with 6.4% over raw LMs, and 2.0% over the prior best LM+KG system, QA-GNN.

Original: The boost over QA-GNN suggests that G REASE LM’s multi-layer fusion components that pass informa- [Table] tion between the text and KG representations is more expressive than LM+KG methods which do not integrate such sustained interaction between both modalities.
Revised: The boost over QA-GNN suggests that G REASE LM’s multi-layer fusion components that pass information between the text and KG representations is more expressive than LM+KG methods which do not integrate such sustained interaction between both modalities.

Original: We also achieve competitive results to other systems on the leaderboard of OpenBookQA (Table 4), posting the third highest score.
Revised: We also achieve competitive results to other systems on the leaderboard of OpenBookQA (Table 4), posting the third highest score.

Original: However, we note that the T5 (Raffel et al., 2020) and UniﬁedQA (Khashabi et al., 2020) models are pretrained models with 8 × and 30 × more parameters, respectively, than our model.
Revised: However, we note that the T5 (Raffel et al., 2020) and UniﬁedQA (Khashabi et al., 2020) models are pretrained models with 8 × and 30 × more parameters, respectively, than our model.

Original: Among models with comparable parameter counts, G REASE LM achieves the highest score.
Revised: Among models with comparable parameter counts, G REASE LM achieves the highest score.

Original: Parameter counts were taken from system descriptions on leaderboards or retrieved from published works. 
Revised: Parameter counts were taken from system descriptions on leaderboards or retrieved from published works. [Table]

Original: Analysis.
Revised: Analysis.

Original: Given these overall performance increases, we investigated whether G REASE LM’s improvements were reﬂected in questions that required more complex reasoning.
Revised: Given these overall performance increases, we investigated whether G REASE LM’s improvements were reﬂected in questions that required more complex reasoning.

Original: Because we had no gold structures from these datasets to categorize the reasoning complexity of different questions, we deﬁned three proxies: the number of prepositional phrases in the questions, the presence of negation terms, and the presence of hedging terms.
Revised: Because we had no gold structures from these datasets to categorize the reasoning complexity of different questions, we deﬁned three proxies: the number of prepositional phrases in the questions, the presence of negation terms, and the presence of hedging terms.

Original: We use the number of prepositional phrases as a proxy for the number of explicit reasoning constraints being set in the questions.
Revised: We use the number of prepositional phrases as a proxy for the number of explicit reasoning constraints being set in the questions.

Original: For example, in the CommonsenseQA question in Table 1, “A weasel has a thin body and short legs to easier burrow after prey in a what?”
Revised: For example, in the CommonsenseQA question in Table 1, “A weasel has a thin body and short legs to easier burrow after prey in a what?”

Original: has three prepositional phrases: to easier burrow , after prey , in a what , which each provide an additional constraint in the search for the answer ( n.b. , in certain cases, the prepositional phrases do not provide constraints that are needed for selecting the correct answer).
Revised: has three prepositional phrases: to easier burrow , after prey , in a what , which each provide an additional constraint in the search for the answer ( n.b. , in certain cases, the prepositional phrases do not provide constraints that are needed for selecting the correct answer).

Original: The presence of negation and hedging terms stratiﬁes our evaluation to questions that have explicit negation mentions ( e.g. , no , never ) and terms indicating uncertainty ( e.g. , sometimes ; maybe ), respectively.
Revised: The presence of negation and hedging terms stratiﬁes our evaluation to questions that have explicit negation mentions ( e.g. , no , never ) and terms indicating uncertainty ( e.g. , sometimes ; maybe ), respectively.

Original: Our results in Table 5 demonstrate that G REASE LM generally outperforms RoBERTa-Large and
Revised: Our results in Table 5 demonstrate that G REASE LM generally outperforms RoBERTa-Large and

Original: QA-GNN for both questions with negation terms and hedge terms, indicating G REASE LM handles contexts with nuanced constraints.
Revised: QA-GNN for both questions with negation terms and hedge terms, indicating G REASE LM handles contexts with nuanced constraints.

Original: Furthermore, we also note that G REASE LM performs better than the baselines across all questions with prepositional phrases, our measure for reasoning complexity.
Revised: Furthermore, we also note that G REASE LM performs better than the baselines across all questions with prepositional phrases, our measure for reasoning complexity.

Original: QA-GNN and G REASE LM perform comparably on questions with no prepositional phrases, but the increasing complexity of questions requires deeper cross-modal fusion between language and knowledge representations.
Revised: QA-GNN and G REASE LM perform comparably on questions with no prepositional phrases, but the increasing complexity of questions requires deeper cross-modal fusion between language and knowledge representations.

Original: While QA-GNN’s end fusion approach of initializing a node in the
Revised: While QA-GNN’s end fusion approach of initializing a node in the

Original: GNN from the LM’s ﬁnal representation of the context is an effective approach, it compresses the language context to a single vector before allowing interaction with the KG, potentially limiting the cross-relationships between language and knowledge that can be captured.
Revised: GNN from the LM’s ﬁnal representation of the context is an effective approach, it compresses the language context to a single vector before allowing interaction with the KG, potentially limiting the cross-relationships between language and knowledge that can be captured.

Original: Interestingly, we note that both G REASE LM and QA-GNN signiﬁcantly outperform RoBERTa-Large even when no prepositional phrases are in the question.
Revised: Interestingly, we note that both G REASE LM and QA-GNN signiﬁcantly outperform RoBERTa-Large even when no prepositional phrases are in the question.

Original: We hypothesize that some of these questions may require less reasoning, but require speciﬁc commonsense knowledge that RoBERTa may not have learned during pretraining ( e.g. , ’What is a person considered a bully known for?’).
Revised: We hypothesize that some of these questions may require less reasoning, but require speciﬁc commonsense knowledge that RoBERTa may not have learned during pretraining ( e.g. , ’What is a person considered a bully known for?’).

Original: 5. A BLATION STUDIES
Revised: 5. A BLATION STUDIES

Original: In Table 6, we summarize an ablation study conducted using the CommonsenseQA IHdev set.
Revised: In Table 6, we summarize an ablation study conducted using the CommonsenseQA IHdev set.

Original: Modality interaction.
Revised: Modality interaction.

Original: A key component of G REASE LM is the connection of the LM to the GNN via the modality interaction module (Eq. 11).
Revised: A key component of G REASE LM is the connection of the LM to the GNN via the modality interaction module (Eq. 11).

Original: If we remove modality interaction, the performance drops signiﬁcantly, from 78.5% to 76.5% (approximately the performance of QA-GNN).
Revised: If we remove modality interaction, the performance drops signiﬁcantly, from 78.5% to 76.5% (approximately the performance of QA-GNN).

Original: Integrating the modality interaction in every other layer instead of consecutive layers also hurts performance.
Revised: Integrating the modality interaction in every other layer instead of consecutive layers also hurts performance.

Original: A possible explanation is that skipping layers could impede learning consistent representations across layers for both the LM and the GNN, a property which may be desirable given we initialize the model using a pretrained LM’s weights ( e.g. , RoBERTa).
Revised: A possible explanation is that skipping layers could impede learning consistent representations across layers for both the LM and the GNN, a property which may be desirable given we initialize the model using a pretrained LM’s weights ( e.g. , RoBERTa).

Original: We also ﬁnd that sharing parameters[Table] between modality interaction layers (Eq. 11) outperforms not sharing, possibly because our datasets are not very large ( e.g. , 10k for CommonsenseQA), and sharing parameters helps prevent overﬁtting. 
Revised: We also ﬁnd that sharing parameters between modality interaction layers (Eq. 11) outperforms not sharing, possibly because our datasets are not very large ( e.g. , 10k for CommonsenseQA), and sharing parameters helps prevent overﬁtting. Number of G REASE LM layers.

Revised: We ﬁnd that M = 5 G REASE LM layers achieves the highest performance.

Revised: However, both the results for M = 4 and M = 6 are relatively close to the top performance, indicating our method is not overly sensitive to this hyperparameter.

Original: Graph connectivity.
Revised: Graph connectivity.

Original: The interaction node e int is a key component of G REASE LM that bridges the interaction between the KG and the text.
Revised: The interaction node e int is a key component of G REASE LM that bridges the interaction between the KG and the text.

Original: Selecting which nodes in the KG are directly connected to e int affects the rate at which information from different portions of the KG can reach the text  representations.
Revised: Selecting which nodes in the KG are directly connected to e int affects the rate at which information from different portions of the KG can reach the text [Table] representations.

Original: We ﬁnd that connecting e int KG nodes explicitly linked to the input text performs best.
Revised: We ﬁnd that connecting e int KG nodes explicitly linked to the input text performs best.

Original: Connecting e int to all nodes in the subgraph ( e
Revised: Connecting e int to all nodes in the subgraph ( e

Original: [Table]
Revised: [Table]

Original: g. , bridge entities) hurts performance (-0.9%).
Revised: g. , bridge entities) hurts performance (-0.9%), possibly because the interaction node is overloaded by having to attend to all nodes in the graph (up to 200).

Revised: By connecting the interaction node only to linked entities, each linked entity serves as a ﬁlter for relevant information that reaches the interaction node.

Original: KG node embedding initialization.
Revised: KG node embedding initialization.

Original: Effectively initializing KG node representations is critical.
Revised: Effectively initializing KG node representations is critical.

Original: When we initialize nodes randomly instead of using the BERT-based initialization method from
Revised: When we initialize nodes randomly instead of using the BERT-based initialization method from

Original: Feng et al.
Revised: Feng et al.

Original: [Table]
Revised: [Table]

Original: the performance drops signiﬁcantly (78.5% → 60.8%).
Revised: the performance drops signiﬁcantly (78.5% → 60.8%).

Original: While using standard KG embeddings ( e
Revised: While using standard KG embeddings ( e

Original: [Table]
Revised: [Table]

Original: g. , TransE; Bordes et al., 2013) recovers much of the performance drop (77.7%), we still ﬁnd that using BERT-based entity embeddings performs best.
Revised: g. , TransE; Bordes et al., 2013) recovers much of the performance drop (77.7%), we still ﬁnd that using BERT-based entity embeddings performs best.

Original: 5. D OMAIN GENERALITY
Revised: 5. D OMAIN GENERALITY

Original: [Table]
Revised: [Table]

Original: Our reported results thus far demonstrate the viability of our method in the general commonsense reasoning domain.
Revised: Our reported results thus far demonstrate the viability of our method in the general commonsense reasoning domain.

Original: In this section, we explore whether G REASE LM could be adapted to other domains by evaluating on the MedQAUSMLE dataset.
Revised: In this section, we explore whether G REASE LM could be adapted to other domains by evaluating on the MedQAUSMLE dataset.

Original: Our results in Table 7 demonstrate that G REASE LM outperforms state-ofthe-art ﬁne-tuned LMs (e.g., SapBERT) and a QA-GNN augmentation of SapBERT.
Revised: Our results in Table 7 demonstrate that G REASE LM outperforms state-ofthe-art ﬁne-tuned LMs (e.g., SapBERT) and a QA-GNN augmentation of SapBERT.

Original: Additionally, we note the improved performance over all classical methods and LM methods ﬁrst reported in Jin et al.
Revised: Additionally, we note the improved performance over all classical methods and LM methods ﬁrst reported in Jin et al.

Original: While these results are promising as they suggest that G REASE LM is an effective augmentation of pretrained language models across different domains and
Revised: While these results are promising as they suggest that G REASE LM is an effective augmentation of pretrained language models across different domains and

Original: KGs (i.e., the biomedical domain with the DDB + Drugbank KG in addition to the commonsense domain), there is still ample room for improvement on this task.
Revised: KGs (i.e., the biomedical domain with the DDB + Drugbank KG), there is still ample room for improvement on this task.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we introduce G REASE LM, a new model that enables interactive fusion through joint information exchange between knowledge from language models and knowledge graphs.
Revised: In this paper, we introduce G REASE LM, a new model that enables interactive fusion through joint information exchange between knowledge from language models and knowledge graphs.

Original: Experimental results demonstrate superior performance compared to prior KG+LM and LM-only baselines across standard datasets from multiple domains (commonsense and medical).
Revised: Experimental results demonstrate superior performance compared to prior KG+LM and LM-only baselines across standard datasets from multiple domains (commonsense and medical).

Original: Our analysis shows improved capability modeling questions exhibiting textual nuances, such as negation and hedging.
Revised: Our analysis shows improved capability modeling questions exhibiting textual nuances, such as negation and hedging.

Original:  E THICS S TATEMENT
Revised:  E THICS S TATEMENT

Original: We outline potential ethical issues with our work below.
Revised: We outline potential ethical issues with our work below.

Original: First, G REASE LM is a method to fuse language representations and knowledge graph representations for effective reasoning about textual situations.
Revised: First, G REASE LM is a method to fuse language representations and knowledge graph representations for effective reasoning about textual situations.

Original: Consequently, G REASE LM could reﬂect many of the same biases and toxic behaviors exhibited by language models and knowledge graphs that are used to initialize it.
Revised: Consequently, G REASE LM could reﬂect many of the same biases and toxic behaviors exhibited by language models and knowledge graphs that are used to initialize it.

Original: For example, prior large-scale language models have been shown to encode biases about race, gender, and other demographic attributes (Sheng et al., 2020).
Revised: For example, prior large-scale language models have been shown to encode biases about race, gender, and other demographic attributes (Sheng et al., 2020).

Original: Because G REASE LM is seeded with pretrained language models that often learn these patterns, it is possible to reﬂect them in open-world settings.
Revised: Because G REASE LM is seeded with pretrained language models that often learn these patterns, it is possible to reﬂect them in open-world settings.

Original: Second, the ConceptNet knowledge graph (Speer et al., 2017) used in this work has been shown to encode stereotypes (Mehrabi et al., 2021), rather than completely clean commonsense knowledge.
Revised: Second, the ConceptNet knowledge graph (Speer et al., 2017) used in this work has been shown to encode stereotypes (Mehrabi et al., 2021), rather than completely clean commonsense knowledge.

Original: If G REASE LM were used outside these standard benchmarks in conjunction with ConceptNet as a
Revised: If G REASE LM were used outside these standard benchmarks in conjunction with ConceptNet as a

Original: KG, it might rely on unethical relationships in its knowledge resource to arrive at conclusions.
Revised: KG, it might rely on unethical relationships in its knowledge resource to arrive at conclusions.

Original: Consequently, while G REASE LM could be used for applications outside these standard benchmarks, we would encourage implementers to use the same precautions they would apply to other language models and methods that use noisy knowledge sources.
Revised: Consequently, while G REASE LM could be used for applications outside these standard benchmarks, we would encourage implementers to use the same precautions they would apply to other language models and methods that use noisy knowledge sources.

Original: Another source of ethical concern is the use of the MedQA-USMLE evaluation.
Revised: Another source of ethical concern is the use of the MedQA-USMLE evaluation.

Original: While we ﬁnd clinical reasoning using language models and knowledge graphs to be an interesting testbed for
Revised: While we ﬁnd clinical reasoning using language models and knowledge graphs to be an interesting testbed for

Original: G REASE LM and for joint language and reasoning models in general, we do not encourage users to use these models for real world clinical prediction, particularly at these performance levels.
Revised: G REASE LM and for joint language and reasoning models in general, we do not encourage users to use these models for real world clinical prediction, particularly at these performance levels.

Original:  R EPRODUCIBILITY S TATEMENT
Revised:  R EPRODUCIBILITY S TATEMENT

Original: To encourage reproducibility, we have outlined the speciﬁc datasets evaluated in our work, and provided a list of hyperparameters for each experiment in Appendix Table 8.
Revised: To encourage reproducibility, we have outlined the speciﬁc datasets evaluated in our work, and provided a list of hyperparameters for each experiment in Appendix Table 8.

Original: Code will be shared privately with the reviewers and ACs, and  made public upon release of the paper.
Revised: Code has been shared privately with the reviewers and ACs, and will be made public upon release of the paper.

Original: A A PPENDIX
Revised: A E XPERIMENTAL S ETUP D ETAILS A. E NTITY L INKING

Revised: Given each QA context, we follow the procedure from Yasunaga et al. (2021) to retrieve the subgraph G sub from G .

Revised: First, we perform entity linking to G to retrieve an initial set of nodes V linked .

Revised: Second, we add any bridge entities that are in a 2-hop path between any pair of linked entities in V linked to get the set of retrieved entities V retrieved .

Revised: Then we prune the set of nodes V retrieved using a relevance score computed for each node.

Revised: To compute the relevance score, we follow the procedure of Yasunaga et al.

Original: [Table]
Revised: (2021) – we concatenate the node name with the context of the QA example, and pass it through a pre-trained LM, using the output score of the node name as the relevance score. We only retain the top 200 scores nodes and prune the remaining ones. Finally, we retrieve all the edges that connect any two nodes in V sub , forming the retrieved subgraph G sub . Each node in G sub is assigned a type according to whether its corresponding entity was linked from the context c , question q , answer a , or from a bridge path.

Revised: A. G RAPH I NITIALIZATION

Revised: To compute initial node embeddings (§3.3) for entities retrieved in G sub from ConceptNet, we follow the method of MHGRN (Feng et al., 2020).

Revised: We convert knowledge triples in the KG into sentences using pre-deﬁned templates for each relation.

Revised: Then, these sentences are fed into a BERT-large LM to compute embeddings for each sentence.

Original: [Figure]
Revised: Finally, for all sentences containing an entity, we extract all token representations of the entity’s mention spans in these sentences, mean pool over these representations and project this mean-pooled representation. For MedQA-USMLE, node embeddings are initialized similarly using the pooled token output embeddings of the entity name from the SapBERT model (described in §4.2; Liu et al., 2020). For MedQA, 5% of examples do not yield a retrieved entity.

Revised: In these cases, we represent the graph using a dummy node initialized with 0.

Revised: In essence, GreaseLM backs off to only using LM representations as the graph propagates no information

Original: [Table]
Revised: [Table]

Revised: A. H YPERPARAMETERS

Original:  [Figure]
Revised: [Table] [Figure] [Table] [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Revised: B A DDITIONAL E XPERIMENTAL R ESULTS

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: To evaluate whether our method is agnostic to the LM used to seed the GreaseLM layers

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: we replace the LMs we use in previous experiments (RoBERTa-large for CommonsenseQA and SapBERT for MedQA-USMLE) with RoBERTa-base for CommonsenseQA

Original: [Table]
Revised: [Table]

Original: [Figure] [Table] [Figure]
Revised: and BioBERT and PubmedBERT for MedQA-USMLE. Across two domains, our results demonstrate that G REASE LM can provide a consistent improvement for multiple LMs when used as a modality junction between KGs and language

Original: [Table] [Figure]
Revised: [Table] [Table]