# QA-GNN: Reasoning with Language Models and Knowledge Graphs
for Question Answering

Michihiro Yasunaga, Hongyu Ren, Antoine Bosselut
Percy Liang, Jure Leskovec
Stanford University
<EMAIL_ADDRESS>
###### Abstract

The problem of answering questions using knowledge from pre-trained language
models (LMs) and knowledge graphs (KGs) presents two challenges: given a QA
context (question and answer choice), methods need to (i) identify relevant
knowledge from large KGs, and (ii) perform joint reasoning over the QA context
and KG. In this work, we propose a new model, QA-GNN, which addresses the
above challenges through two key innovations: (i) relevance scoring, where we
use LMs to estimate the importance of KG nodes relative to the given QA
context, and (ii) joint reasoning, where we connect the QA context and KG to
form a joint graph, and mutually update their representations through graph
neural networks. We evaluate our model on QA benchmarks in the commonsense
(CommonsenseQA, OpenBookQA) and biomedical (MedQA-USMLE) domains. QA-GNN
outperforms existing LM and LM+KG models, and exhibits capabilities to perform
interpretable and structured reasoning, e.g., correctly handling negation in
questions. Our code and data are available at
https://github.com/michiyasunaga/qagnn.

##  1 Introduction

Question answering systems must be able to access relevant knowledge and
reason over it. Typically, knowledge can be implicitly encoded in large
language models (LMs) pre-trained on unstructured text Petroni et al. (2019);
Bosselut et al. (2019), or explicitly represented in structured knowledge
graphs (KGs), such as Freebase Bollacker et al. (2008) and ConceptNet Speer et
al. (2017), where entities are represented as nodes and relations between them
as edges. Recently, pre-trained LMs have demonstrated remarkable success in
many question answering tasks Liu et al. (2019); Raffel et al. (2020).
However, while LMs have a broad coverage of knowledge, they do not empirically
perform well on structured reasoning (e.g., handling negation) Kassner and
Schütze (2020). On the other hand, KGs are more suited for structured
reasoning Ren et al. (2020); Ren and Leskovec (2020) and enable explainable
predictions e.g., by providing reasoning paths Lin et al. (2019), but may lack
coverage and be noisy Bordes et al. (2013); Guu et al. (2015). How to reason
effectively with both sources of knowledge remains an important open problem.

Figure 1: Given the QA context (question and answer choice; purple box), we
aim to derive the answer by performing joint reasoning over the language and
the knowledge graph (green box).  Figure 2: Overview of our approach. Given a
QA context ($z$), we connect it with the retrieved KG to form a joint graph
(working graph; §3.1), compute the relevance of each KG node conditioned on
$z$ (§3.2; node shading indicates the relevance score), and perform reasoning
on the working graph (§3.3).

Combining LMs and KGs for reasoning (henceforth, LM+KG) presents two
challenges: given a QA context (e.g., question and answer choices; Figure 1
purple box), methods need to (i) identify informative knowledge from a large
KG (green box); and (ii) capture the nuance of the QA context and the
structure of the KGs to perform joint reasoning over these two sources of
information. Previous works Bao et al. (2016); Sun et al. (2018); Lin et al.
(2019) retrieve a subgraph from the KG by taking topic entities (KG entities
mentioned in the given QA context) and their few-hop neighbors. However, this
introduces many entity nodes that are semantically irrelevant to the QA
context, especially when the number of topic entities or hops increases.
Additionally, existing LM+KG methods for reasoning Lin et al. (2019); Wang et
al. (2019a); Feng et al. (2020); Lv et al. (2020) treat the QA context and KG
as two separate modalities. They individually apply LMs to the QA context and
graph neural networks (GNNs) to the KG, and do not mutually update or unify
their representations. This separation might limit their capability to perform
structured reasoning, e.g., handling negation.

Here we propose QA-GNN, an end-to-end LM+KG model for question answering that
addresses the above two challenges. We first encode the QA context using an
LM, and retrieve a KG subgraph following prior works Feng et al. (2020). Our
QA-GNN has two key insights: (i) Relevance scoring: Since the KG subgraph
consists of all few-hop neighbors of the topic entities, some entity nodes are
more relevant than others with respect to the given QA context. We hence
propose KG node relevance scoring: we score each entity on the KG subgraph by
concatenating the entity with the QA context and calculating the likelihood
using a pre-trained LM. This presents a general framework to weight
information on the KG; (ii) Joint reasoning: We design a joint graph
representation of the QA context and KG, where we explicitly view the QA
context as an additional node (QA context node) and connect it to the topic
entities in the KG subgraph as shown in Figure 1. This joint graph, which we
term the working graph, unifies the two modalities into one graph. We then
augment the feature of each node with the relevance score, and design a new
attention-based GNN module for reasoning. Our joint reasoning algorithm on the
working graph simultaneously updates the representation of both the KG
entities and the QA context node, bridging the gap between the two sources of
information.

We evaluate QA-GNN on three question answering datasets that require reasoning
with knowledge: CommonsenseQA Talmor et al. (2019) and OpenBookQA Mihaylov et
al. (2018) in the commonsense domain (using the ConceptNet KG), and MedQA-
USMLE Jin et al. (2021) in the biomedical domain (using the UMLS and DrugBank
KGs). QA-GNN outperforms strong fine-tuned LM baselines as well as the
existing best LM+KG model (with the same LM) by 4.7% and 2.3% respectively. In
particular, QA-GNN exhibits improved performance on some forms of structured
reasoning (e.g., correctly handling negation and entity substitution in
questions): it achieves 4.6% improvement over fine-tuned LMs on questions with
negation, while existing LM+KG models are +0.6% over fine-tuned LMs. We also
show that one can extract reasoning processes from QA-GNN in the form of
general KG subgraphs, not just paths Lin et al. (2019), suggesting a general
method for explaining model predictions.

##  2 Problem statement

We aim to answer natural language questions using knowledge from a pre-trained
LM and a structured KG. We use the term language model broadly to be any
composition of two functions, $f_{\text{head}}(f_{\text{enc}}(\mathbf{x}))$,
where $f_{\text{enc}}$, the encoder, maps a textual input $\mathbf{x}$ to a
contextualized vector representation $\mathbf{h}^{\text{LM}}$, and
$f_{\text{head}}$ uses this representation to perform a desired task (which we
discuss in §3.2). In this work, we specifically use masked language models
(e.g., RoBERTa) as $f_{\text{enc}}$, and let $\mathbf{h}^{\text{LM}}$ denote
the output representation of a [CLS] token that is prepended to the input
sequence $\mathbf{x}$, unless otherwise noted. We define the knowledge graph
as a multi-relational graph ${\mathcal{G}}=({\mathcal{V}},{\mathcal{E}})$.
Here ${\mathcal{V}}$ is the set of entity nodes in the KG;
${\mathcal{E}}\subseteq$ ${\mathcal{V}}\times{\mathcal{R}}\times{\mathcal{V}}$
is the set of edges that connect nodes in ${\mathcal{V}}$, where
${\mathcal{R}}$ represents a set of relation types.

Given a question $q$ and an answer choice $a\in\mathcal{C}$, we follow prior
work Lin et al. (2019) to link the entities mentioned in the question and
answer choice to the given KG ${\mathcal{G}}$. We denote
${\mathcal{V}}_{q}\subseteq{\mathcal{V}}$ and
${\mathcal{V}}_{a}\subseteq{\mathcal{V}}$ as the set of KG entities mentioned
in the question (question entities; blue entities in Figure 1) and answer
choice (answer choice entities; red entities in Figure 1), respectively, and
use ${\mathcal{V}}_{q,a}\coloneqq{\mathcal{V}}_{q}\cup{\mathcal{V}}_{a}$ to
denote all the entities that appear in either the question or answer choice,
which we call topic entities. We then extract a subgraph from ${\mathcal{G}}$
for a question-choice pair,
${\mathcal{G}}_{\text{sub}}^{q,a}=({\mathcal{V}}_{\text{sub}}^{q,a},{\mathcal{E}}_{\text{sub}}^{q,a})$,111We
remove the superscript $q,a$ if there is no ambiguity. which comprises all
nodes on the $k$-hop paths between nodes in ${\mathcal{V}}_{q,a}$.

Figure 3: Relevance scoring of the retrieved KG: we use a pre-trained LM to
calculate the relevance of each KG entity node conditioned on the QA context
(§3.2).

##  3 Approach: QA-GNN

As shown in Figure 2, given a question and an answer choice $a$, we
concatenate them to get the QA context $[q;~{}a]$. To reason over a given QA
context using knowledge from both the LM and the KG, QA-GNN works as follows.
First, we use the LM to obtain a representation for the QA context, and
retrieve the subgraph ${\mathcal{G}}_{\text{sub}}$ from the KG. Then we
introduce a QA context node $z$ that represents the QA context, and connect
$z$ to the topic entities ${\mathcal{V}}_{q,a}$ so that we have a joint graph
over the two sources of knowledge, which we term the working graph,
${\mathcal{G}}_{\text{W}}$ (§3.1). To adaptively capture the relationship
between the QA context node and each of the other nodes in
${\mathcal{G}}_{\text{W}}$, we calculate a relevance score for each pair using
the LM, and use this score as an additional feature for each node (§3.2). We
then propose an attention-based GNN module that performs message passing on
the ${\mathcal{G}}_{\text{W}}$ for multiple rounds (§3.3). We make the final
prediction using the LM representation, QA context node representation and a
pooled working graph representation (§3.4).

We also discuss the computational complexity of our model (§3.5), and why our
model uses a GNN for question answering tasks (§3.6).

###  3.1 Joint graph representation

To design a joint reasoning space for the two sources of knowledge, we
explicitly connect them in a common graph structure. We introduce a new QA
context node $z$ which represents the QA context, and connect $z$ to each
topic entity in ${\mathcal{V}}_{q,a}$ on the KG subgraph
${\mathcal{G}}_{\text{sub}}$ using two new relation types $r_{z,q}$ and
$r_{z,a}$. These relation types capture the relationship between the QA
context and the relevant entities in the KG, depending on whether the entity
is found in the question portion or the answer portion of the QA context.
Since this joint graph intuitively provides a reasoning space (working memory)
over the QA context and KG, we term it working graph
${\mathcal{G}}_{\text{W}}=({\mathcal{V}}_{\text{W}},{\mathcal{E}}_{\text{W}})$,
where ${\mathcal{V}}_{\text{W}}={\mathcal{V}}_{\text{sub}}\cup\\{z\\}$ and
${\mathcal{E}}_{\text{W}}={\mathcal{E}}_{\text{sub}}\cup\\{(z,r_{z,q},v)\mid
v\in{\mathcal{V}}_{q}\\}\cup\\{(z,r_{z,a},v)\mid v\in{\mathcal{V}}_{a}\\}$.

Each node in ${\mathcal{G}}_{\text{W}}$ is associated with one of the four
types: $\mathcal{T}=\\{\textbf{Z},\textbf{Q},\textbf{A},\textbf{O}\\}$, each
indicating the context node $z$, nodes in ${\mathcal{V}}_{q}$, nodes in
${\mathcal{V}}_{a}$, and other nodes, respectively (corresponding to the node
color, purple, blue, red, gray in Figure 1 and 2). We denote the text of the
context node $z$ (QA context) and KG node $v\in{\mathcal{V}}_{\text{sub}}$
(entity name) as $\texttt{text}(z)$ and $\texttt{text}(v)$.

We initialize the node embedding of $z$ by the LM representation of the QA
context ($\bm{z}^{\text{LM}}$ $=$ $f_{\text{enc}}(\texttt{text}(z))$), and
each node on ${\mathcal{G}}_{\text{sub}}$ by its entity embedding (§4.2). In
the subsequent sections, we will reason over the working graph to score a
given (question, answer choice) pair.

###  3.2 KG node relevance scoring

Many nodes on the KG subgraph ${\mathcal{G}}_{\text{sub}}$ (i.e., those
heuristically retrieved from the KG) can be irrelevant under the current QA
context. As an example shown in Figure 3, the retrieved KG subgraph
${\mathcal{G}}_{\text{sub}}$ with few-hop neighbors of the
${\mathcal{V}}_{q,a}$ may include nodes that are uninformative for the
reasoning process, e.g., nodes “holiday” and “river bank” are off-topic;
“human” and “place” are generic. These irrelevant nodes may result in
overfitting or introduce unnecessary difficulty in reasoning, an issue
especially when ${\mathcal{V}}_{q,a}$ is large. For instance, we empirically
find that using the _ConceptNet_ KG Speer et al. (2017), we will retrieve a KG
with $|{\mathcal{V}}_{\text{sub}}|>400$ nodes on average if we consider 3-hop
neighbors.

In response, we propose node relevance scoring, where we use the pre-trained
language model to score the relevance of each KG node
$v\in{\mathcal{V}}_{\text{sub}}$ conditioned on the QA context. For each node
$v$, we concatenate the entity $\texttt{text}(v)$ with the QA context
$\texttt{text}(z)$ and compute the _relevance score_ :

$\displaystyle\rho_{v}=f_{\text{head}}(f_{\text{enc}}([\texttt{text}(z);~{}\texttt{text}(v)])),$
(1)

where $f_{\text{head}}\circ f_{\text{enc}}$ denotes the probability of
$\texttt{text}(v)$ computed by the LM. This relevance score $\rho_{v}$
captures the importance of each KG node relative to the given QA context,
which is used for reasoning or pruning the working graph
${\mathcal{G}}_{\text{W}}$.

###  3.3 GNN architecture

To perform reasoning on the working graph ${\mathcal{G}}_{\text{W}}$, our GNN
module builds on the graph attention framework (GAT) (Veličković et al.,
2018), which induces node representations via iterative message passing
between neighbors on the graph. Specifically, in a $L$-layer QA-GNN, for each
layer, we update the representation $\bm{h}_{t}^{(\ell)}\in\mathbb{R}^{D}$ of
each node $t\in{\mathcal{V}}_{\text{W}}$ by

$\displaystyle\bm{h}_{t}^{(\ell+1)}={f}_{n}\Biggl{(}\sum_{s\in\mathcal{N}_{t}\cup\\{t\\}}\alpha_{st}\bm{m}_{st}\Biggr{)}+\bm{h}_{t}^{(\ell)},$
(2)

where ${\mathcal{N}}_{t}$ represents the neighborhood of node $t$,
$\bm{m}_{st}\in\mathbb{R}^{D}$ denotes the message from each neighbor node $s$
to $t$, and $\alpha_{st}$ is an attention weight that scales each message
$\bm{m}_{st}$ from $s$ to $t$. The sum of the messages is then passed through
a 2-layer MLP, ${f}_{n}$: $\mathbb{R}^{D}\rightarrow\mathbb{R}^{D}$, with
batch normalization (Ioffe and Szegedy, 2015). For each node
$t\in{\mathcal{V}}_{\text{W}}$, we set $\bm{h}^{(0)}_{t}$ using a linear
transformation $f_{h}$ that maps its initial node embedding (described in
§3.1) to $\mathbb{R}^{D}$. Crucially, as our GNN message passing operates on
the working graph, it will jointly leverage and update the representation of
the QA context and KG.

We further propose an expressive message ($\bm{m}_{st}$) and attention
($\alpha_{st}$) computation below.

##### Node type & relation-aware message.

As ${\mathcal{G}}_{\text{W}}$ is a multi-relational graph, the message passed
from a source node to the target node should capture their relationship, i.e.,
relation type of the edge and source/target node types. To this end, we first
obtain the type embedding $\bm{u}_{t}$ of each node $t$, as well as the
relation embedding $\bm{r}_{st}$ from node $s$ to node $t$ by

$\displaystyle\bm{u}_{t}={f}_{u}(\texttt{u}_{t}),~{}~{}~{}~{}\bm{r}_{st}={f}_{r}(\texttt{e}_{st},~{}\texttt{u}_{s},~{}\texttt{u}_{t}),$
(3)

where $\texttt{u}_{s},\texttt{u}_{t}\in\\{0,1\\}^{|\mathcal{T}|}$ are one-hot
vectors indicating the node types of $s$ and $t$,
$\texttt{e}_{st}\in\\{0,1\\}^{|\mathcal{R}|}$ is a one-hot vector indicating
the relation type of edge ($s,t$), ${f}_{u}$:
$\mathbb{R}^{|\mathcal{T}|}\rightarrow\mathbb{R}^{D/2}$ is a linear
transformation, and ${f}_{r}$:
$\mathbb{R}^{|\mathcal{R}|+2|\mathcal{T}|}\rightarrow\mathbb{R}^{D}$ is a
2-layer MLP. We then compute the message from $s$ to $t$ as

$\displaystyle\bm{m}_{st}$
$\displaystyle={f}_{m}(\bm{h}_{s}^{(\ell)},~{}\bm{u}_{s},~{}\bm{r}_{st}),$ (4)

where ${f}_{m}$: $\mathbb{R}^{2.5D}\rightarrow\mathbb{R}^{D}$ is a linear
transformation.

##### Node type, relation, and score-aware attention.

Attention captures the strength of association between two nodes, which is
ideally informed by their node types, relations and node relevance scores.

We first embed the relevance score of each node $t$ by

$\displaystyle\bm{\rho}_{t}$ $\displaystyle={f}_{\rho}(\rho_{t}),$ (5)

where ${f}_{\rho}$: $\mathbb{R}\rightarrow\mathbb{R}^{D/2}$ is an MLP. To
compute the attention weight $\alpha_{st}$ from node $s$ to node $t$, we
obtain the query and key vectors $\bm{q}$, $\bm{k}$ by

$\displaystyle\bm{q}_{s}$
$\displaystyle={f}_{q}(\bm{h}_{s}^{(\ell)},~{}\bm{u}_{s},~{}\bm{\rho}_{s}),$
(6) $\displaystyle\bm{k}_{t}$
$\displaystyle={f}_{k}(\bm{h}_{t}^{(\ell)},~{}\bm{u}_{t},~{}\bm{\rho}_{t},~{}\bm{r}_{st}),$
(7)

where ${f}_{q}$: $\mathbb{R}^{2D}\rightarrow\mathbb{R}^{D}$ and ${f}_{k}$:
$\mathbb{R}^{3D}\rightarrow\mathbb{R}^{D}$ are linear transformations. The
attention weight is then

$\displaystyle\alpha_{st}=\frac{\exp(\gamma_{st})}{\sum_{t^{\prime}\in\mathcal{N}_{s}\cup\\{s\\}}\exp(\gamma_{st^{\prime}})},~{}~{}~{}\gamma_{st}=\frac{\bm{q}_{s}^{\top}\bm{k}_{t}}{\sqrt{D}}.$
(8)

###  3.4 Inference & Learning

Given a question $q$ and an answer choice $a$, we use the information from
both the QA context and the KG to calculate the probability of it being the
answer $p(a\mid
q)\propto\exp(\text{MLP}(\bm{z}^{\text{LM}},~{}\bm{z}^{\text{GNN}},~{}\bm{g}))$,
where $\bm{z}^{\text{GNN}}={\bm{h}}^{(L)}_{z}$ and $\bm{g}$ denotes the
pooling of $\\{{\bm{h}}^{(L)}_{v}\mid v\in\mathcal{V}_{\text{sub}}\\}$. In the
training data, each question has a set of answer choices with one correct
choice. We optimize the model (both the LM and GNN components end-to-end)
using the cross entropy loss.

###  3.5 Computation complexity

We analyze the time and space complexity of our model and compare with prior
works, KagNet Lin et al. (2019) and MHGRN Feng et al. (2020) in Table 1. As we
handle edges of different relation types using different edge embeddings
instead of designing an independent graph networks for each relation as in
RGCN Schlichtkrull et al. (2018) or MHGRN, the time complexity of our method
is constant with respect to the number of relations and linear with respect to
the number of nodes. We achieve the same space complexity as MHGRN Feng et al.
(2020).

Model | Time | Space
---|---|---
$\mathcal{G}$ is a dense graph
$L$-hop KagNet | $\mathcal{O}\left(|{\mathcal{R}}|^{L}|{\mathcal{V}}|^{L+1}L\right)$ | $\mathcal{O}\left(|{\mathcal{R}}|^{L}|{\mathcal{V}}|^{L+1}L\right)$
$L$-hop MHGRN | $\mathcal{O}\left(|{\mathcal{R}}|^{2}|{\mathcal{V}}|^{2}L\right)$ | $\mathcal{O}\left(|{\mathcal{R}}||{\mathcal{V}}|L\right)$
$L$-layer QA-GNN  | $\mathcal{O}\left(|{\mathcal{V}}|^{2}L\right)$ | $\mathcal{O}\left(|{\mathcal{R}}||{\mathcal{V}}|L\right)$
$\mathcal{G}$ is a sparse graph with maximum node degree
$\Delta\ll|{\mathcal{V}}|$
$L$-hop KagNet | $\mathcal{O}\left(|{\mathcal{R}}|^{L}|{\mathcal{V}}|L\Delta^{L}\right)$ | $\mathcal{O}\left(|{\mathcal{R}}|^{L}|{\mathcal{V}}|L\Delta^{L}\right)$
$L$-hop MHGRN | $\mathcal{O}\left(|{\mathcal{R}}|^{2}|{\mathcal{V}}|L\Delta\right)$ | $\mathcal{O}\left(|{\mathcal{R}}||{\mathcal{V}}|L\right)$
$L$-layer QA-GNN  | $\mathcal{O}\left(|{\mathcal{V}}|L\Delta\right)$ | $\mathcal{O}\left(|{\mathcal{R}}||{\mathcal{V}}|L\right)$

Table 1: Computation complexity of different $L$-hop reasoning models on a
dense / sparse graph ${\mathcal{G}}=({\mathcal{V}},{\mathcal{E}})$ with the
relation set ${\mathcal{R}}$.

###  3.6 Why GNN for question answering?

We provide more discussion on why we use a GNN for solving question answering
and reasoning tasks.

Recent work shows that GNNs are effective for modeling various graph
algorithms Xu et al. (2020). Examples of graph algorithms include knowledge
graph reasoning, such as execution of logical queries on a KG Gentner (1983);
Ren and Leskovec (2020):

$\displaystyle V_{?}.~{}\exists V\\!:~{}$
$\displaystyle\text{Located}(\text{Europe},V)$ $\displaystyle\wedge$
$\displaystyle\neg\text{Held}(\text{World
Cup},V)\wedge\text{President}(V,V_{?})$ (“Who are the presents of European
countries that have not held the World Cup?”)

Viewing such logical queries as input “questions”, we conducted a pilot study
where we apply QA-GNN to learn the task of executing logical queries on a
KG—including complex queries that contain negation or multi-hop relations
about entities. In this task, we find that QA-GNN significantly outperforms a
baseline model that only uses an LM but not a GNN:

Methods | Hit@3 on FB15k
---|---
LM-only | 15
QA-GNN (Ours) | 40

Table 2:  Performace in learning to answer complex logical queries on a KG.

The result confirms that GNNs are indeed useful for modeling complex query
answering. This provides an intuition that QA-GNN can be useful for answering
complex natural language questions too, which could be viewed as executing
soft queries—natural language instead of logical—using a KG.

From this “KG query execution” intuition, we may also draw an interpretation
that the KG and GNN can provide a scaffold for the model to reason about
entities mentioned in the question. We further analyze this idea in §4.6.3.

##  4 Experiments

###  4.1 Datasets

We evaluate QA-GNN on three question answering datasets: CommonsenseQA Talmor
et al. (2019), OpenBookQA Mihaylov et al. (2018), and MedQA-USMLE Jin et al.
(2021).

CommonsenseQA is a 5-way multiple choice QA task that requires reasoning with
commonsense knowledge, containing 12,102 questions. The test set of
CommonsenseQA is not publicly available, and model predictions can only be
evaluated once every two weeks via the official leaderboard. Hence, we perform
main experiments on the in-house (IH) data splits used in Lin et al. (2019),
and also report the score of our final system on the official test set.

OpenBookQA is a 4-way multiple choice QA task that requires reasoning with
elementary science knowledge, containing 5,957 questions. We use the official
data splits from Mihaylov and Frank (2018).

MedQA-USMLE is a 4-way multiple choice QA task that requires biomedical and
clinical knowledge. The questions are originally from practice tests for the
United States Medical License Exams (USMLE). The dataset contains 12,723
questions. We use the original data splits from Jin et al. (2021).

###  4.2 Knowledge graphs

For CommonsenseQA and OpenBookQA, we use ConceptNet Speer et al. (2017), a
general-domain knowledge graph, as our structured knowledge source
$\mathcal{G}$. It has 799,273 nodes and 2,487,810 edges in total. Node
embeddings are initialized using the entity embeddings prepared by Feng et al.
(2020), which applies pre-trained LMs to all triples in ConceptNet and then
obtains a pooled representation for each entity.

For MedQA-USMLE, we use a self-constructed knowledge graph that integrates the
Disease Database portion of the Unified Medical Language System (UMLS;
Bodenreider, 2004) and DrugBank Wishart et al. (2018). The knowledge graph
contains 9,958 nodes and 44,561 edges. Node embeddings are initialized using
the pooled representations of the entity name from SapBERT (Liu et al.,
2020a).

Given each QA context (question and answer choice), we retrieve the subgraph
$\mathcal{G}_{\text{sub}}$ from $\mathcal{G}$ following the pre-processing
step described in Feng et al. (2020), with hop size $k=2$. We then prune
$\mathcal{G}_{\text{sub}}$ to keep the top 200 nodes according to the node
relevance score computed in §3.2. Henceforth, in this section (§4) we use the
term “KG” to refer to $\mathcal{G}_{\text{sub}}$.

###  4.3 Implementation & training details

We set the dimension ($D=200$) and number of layers ($L=5$) of our GNN module,
with dropout rate 0.2 applied to each layer Srivastava et al. (2014). We train
the model with the RAdam Liu et al. (2020b) optimizer using two GPUs (GeForce
RTX 2080 Ti), which takes $\sim$20 hours. We set the batch size from {32, 64,
128, 256}, learning rate for the LM module from {5e-6, 1e-5, 2e-5, 3e-5,
5e-5}, and learning rate for the GNN module from {2e-4, 5e-4, 1e-3, 2e-3}. The
above hyperparameters are tuned on the development set.

###  4.4 Baselines

##### Fine-tuned LM.

To study the role of KGs, we compare with a vanilla fine-tuned LM, which does
not use the KG. We use RoBERTa-large Liu et al. (2019) for CommonsenseQA, and
RoBERTa-large and AristoRoBERTa222OpenBookQA provides an extra corpus of
scientific facts in a textual form. AristoRoBERTa uses the facts corresponding
to each question, prepared by Clark et al. (2019), as an additional input to
the QA context. Clark et al. (2019) for OpenBookQA. For MedQA-USMLE, we use a
state-of-the-art biomedical LM, SapBERT Liu et al. (2020a).

##### Existing LM+KG models.

We compare with existing LM+KG methods, which share the same high-level
framework as ours but use different modules to reason on the KG in place of
QA-GNN (“yellow box” in Figure 2): (1) Relation Network (RN) Santoro et al.
(2017), (2) RGCN Schlichtkrull et al. (2018), (3) GconAttn Wang et al.
(2019a), (4) KagNet Lin et al. (2019), and (5) MHGRN Feng et al. (2020).
(1),(2),(3) are relation-aware GNNs for KGs, and (4),(5) further model paths
in KGs. MHGRN is the existing top performance model under this LM+KG
framework. For fair comparison, we use the same LM in all the baselines and
our model. The key differences between QA-GNN and these are that they do not
perform relevance scoring or joint updates with the QA context (§3).

###  4.5 Main results

Methods |  IHdev-Acc. (%) |  IHtest-Acc. (%)
---|---|---
RoBERTa-large (w/o KG) | 73.07 ($\pm$0.45) | 68.69 ($\pm$0.56)
\+ RGCN  Schlichtkrull et al. (2018) | 72.69 ($\pm$0.19) | 68.41 ($\pm$0.66)
\+ GconAttn  Wang et al. (2019a) | 72.61($~{}\pm$0.39) | 68.59 ($\pm$0.96)
\+ KagNet  Lin et al. (2019) | 73.47 ($\pm$0.22) | 69.01 ($\pm$0.76)
\+ RN  Santoro et al. (2017) | 74.57 ($\pm$0.91) | 69.08 ($\pm$0.21)
\+ MHGRN  Feng et al. (2020) | 74.45 ($\pm$0.10) | 71.11 ($\pm$0.81)
\+ QA-GNN (Ours) |  76.54 ($\pm$0.21) |  73.41 ($\pm$0.92)

Table 3: Performance comparison on Commonsense QA in-house split (controlled
experiments). As the official test is hidden, here we report the in-house Dev
(IHdev) and Test (IHtest) accuracy, following the data split of Lin et al.
(2019).

Methods | Test
---|---
RoBERTa Liu et al. (2019) | 72.1
RoBERTa+FreeLB Zhu et al. (2020) (ensemble) | 73.1
RoBERTa+HyKAS Ma et al. (2019) | 73.2
RoBERTa+KE (ensemble) | 73.3
RoBERTa+KEDGN (ensemble) | 74.4
XLNet+GraphReason Lv et al. (2020) | 75.3
RoBERTa+MHGRN Feng et al. (2020) | 75.4
Albert+PG Wang et al. (2020b) | 75.6
Albert Lan et al. (2020) (ensemble) | 76.5
UnifiedQA* Khashabi et al. (2020) | 79.1
RoBERTa + QA-GNN (Ours) | 76.1

Table 4: Test accuracy on CommonsenseQA’s official leaderboard. The top
system, UnifiedQA (11B parameters) is 30x larger than our model.

Methods | RoBERTa-large | AristoRoBERTa
---|---|---
Fine-tuned LMs (w/o KG) | 64.80 ($\pm$2.37) | 78.40 ($\pm$1.64)
\+ RGCN | 62.45 ($\pm$1.57) | 74.60 ($\pm$2.53)
\+ GconAtten | 64.75 ($\pm$1.48) | 71.80 ($\pm$1.21)
\+ RN | 65.20 ($\pm$1.18) | 75.35 ($\pm$1.39)
\+ MHGRN | 66.85 ($\pm$1.19) | 80.6
\+ QA-GNN (Ours) |  67.80 ($\pm$2.75) |  82.77 ($\pm$1.56)

Table 5: Test accuracy comparison on OpenBook QA (controlled experiments).
Methods with AristoRoBERTa use the textual evidence by Clark et al. (2019) as
an additional input to the QA context.

Methods | Test
---|---
Careful Selection Banerjee et al. (2019) | 72.0
AristoRoBERTa | 77.8
KF + SIR Banerjee and Baral (2020) | 80.0
AristoRoBERTa + PG Wang et al. (2020b) | 80.2
AristoRoBERTa + MHGRN Feng et al. (2020) | 80.6
Albert + KB | 81.0
T5* Raffel et al. (2020) | 83.2
UnifiedQA* Khashabi et al. (2020) | 87.2
AristoRoBERTa + QA-GNN (Ours) | 82.8

Table 6: Test accuracy on OpenBookQA leaderboard. All listed methods use the
provided science facts as an additional input to the language context. The top
2 systems, UnifiedQA (11B params) and T5 (3B params) are 30x and 8x larger
than our model.

Methods | Test
---|---
BERT-base  Devlin et al. (2019) | 34.3
BioBERT-base  Lee et al. (2020) | 34.1
RoBERTa-large  Liu et al. (2019) | 35.0
BioBERT-large  Lee et al. (2020) | 36.7
SapBERT  Liu et al. (2020a) | 37.2
SapBERT + QA-GNN (Ours) | 38.0

Table 7:  Test accuracy on MedQA-USMLE.

Table 3 and Table 5 show the results on CommonsenseQA and OpenBookQA,
respectively. On both datasets, we observe consistent improvements over fine-
tuned LMs and existing LM+KG models, e.g., on CommonsenseQA, +4.7% over
RoBERTa, and +2.3% over the prior best LM+KG system, MHGRN. The boost over
MHGRN suggests that QA-GNN makes a better use of KGs to perform joint
reasoning than existing LM+KG methods.

We also achieve competitive results to other systems on the official
leaderboards (Table 4 and 6). Notably, the top two systems, T5 Raffel et al.
(2020) and UnifiedQA Khashabi et al. (2020), are trained with more data and
use 8x to 30x more parameters than our model (ours has $\sim$360M parameters).
Excluding these and ensemble systems, our model is comparable in size and
amount of data to other systems, and achieves the top performance on the two
datasets.

Table 7 shows the result on MedQA-USMLE. QA-GNN outperforms state-of-the-art
fine-tuned LMs (e.g., SapBERT). This result suggests that our method is an
effective augmentation of LMs and KGs across different domains (i.e., the
biomedical domain besides the commonsense domain).

###  4.6 Analysis

####  4.6.1 Ablation studies

Table 8: Ablation study of our model components, using the CommonsenseQA IHdev
set.

Table 8 summarizes the ablation study conducted on each of our model
components (§3.1, §3.2, §3.3), using the CommonsenseQA IHdev set.

##### Graph connection

(top left table): The first key component of QA-GNN is the joint graph
that connects the $z$ node (QA context) to QA entity nodes $\mathcal{V}_{q,a}$
in the KG (§3.1). Without these edges, the QA context and KG cannot mutually
update their representations, hurting the performance: 76.5% $\rightarrow$
74.8%, which is close to the previous LM+KG system, MHGRN. If we connected $z$
to all the nodes in the KG (not just QA entities), the performance is
comparable or drops slightly (-0.16%).

##### KG node relevance scoring

(top right table): We find the relevance scoring of KG nodes (§3.2)
provides a boost: 75.56% $\\!\rightarrow\\!$ 76.54%. As a variant of the
relevance scoring in Eq. 1, we also experimented with obtaining a _contextual
embedding_ ${\bm{w}}_{v}$ for each node $v\in{\mathcal{V}}_{\text{sub}}$ and
adding to the node features:
${\bm{w}}_{v}=f_{\text{enc}}([\texttt{text}(z);~{}\texttt{text}(v)])$.
However, we find that it does not perform as well (76.31%), and using both the
relevance score and contextual embedding performs on par with using the score
alone, suggesting that the score has a sufficient information in our tasks;
hence, our final system simply uses the relevance score.

##### GNN architecture

(bottom tables): We ablate the information of node type, relation, and
relevance score from the attention and message computation in the GNN (§3.3).
The results suggest that all these features improve the model performance. For
the number of GNN layers, we find $L=5$ works the best on the dev set. Our
intuition is that 5 layers allow various message passing or reasoning patterns
between the QA context ($z$) and KG, such as “$z$ $\\!\rightarrow\\!$ 3 hops
on KG nodes $\\!\rightarrow\\!$ $z$”.

####  4.6.2 Model interpretability

Figure 4: Interpreting QA-GNN’s reasoning process by analyzing the node-to-
node attention weights induced by the GNN. Darker and thicker edges indicate
higher attention weights.

We aim to interpret QA-GNN’s reasoning process by analyzing the node-to-node
attention weights induced by the GNN. Figure 4 shows two examples. In (a), we
perform Best First Search (BFS) on the working graph to trace high attention
weights from the QA context node (Z; purple) to Question entity nodes (blue)
to Other (gray) or Answer choice entity nodes (orange), which reveals that the
QA context $z$ attends to “elevator” and “basement” in the KG, “elevator” and
“basement” both attend strongly to “building”, and “building” attends to
“office building”, which is our final answer. In (b), we use BFS to trace
attention weights from two directions: Z $\\!\rightarrow\\!$ Q
$\\!\rightarrow\\!$ O and Z $\\!\rightarrow\\!$ A $\\!\rightarrow\\!$ O, which
reveals concepts (“sea” and “ocean”) in the KG that are not necessarily
mentioned in the QA context but bridge the reasoning between the question
entity (“crab”) and answer choice entity (“salt water”). While prior KG
reasoning models Lin et al. (2019); Feng et al. (2020) enumerate individual
paths in the KG for model interpretation, QA-GNN is not specific to paths, and
helps to find more general reasoning structures (e.g., a KG subgraph with
multiple anchor nodes as in example (a)).

Figure 5: Analysis of QA-GNN’s behavior for structured reasoning. Given an
original question (left), we modify its negation (middle) or topic entity
(right): we find that QA-GNN adapts attention weights and final predictions
accordingly, suggesting its capability to handle structured reasoning.  Table
9: Case study of structured reasoning, comparing predictions by RoBERTa and
our model (RoBERTa + QA-GNN). Our model correctly handles changes in negation
and topic entities.

####  4.6.3 Structured reasoning

Structured reasoning, e.g., precise handling of negation or entity
substitution (e.g., “hair” $\\!\rightarrow\\!$ “art” in Figure 5b) in
question, is crucial for making robust predictions. Here we analyze QA-GNN’s
ability to perform structured reasoning and compare with baselines (fine-tuned
LMs and existing LM+KG models).

##### Quantitative analysis.

Methods | IHtest-Acc. | IHtest-Acc.
---|---|---
(Overall) |  (Question w/ negation)
RoBERTa-large (w/o KG) | 68.7 | 54.2
\+ KagNet | 69.0 (+0.3) | 54.2 (+0.0)
\+ MHGRN | 71.1 (+2.4) | 54.8 (+0.6)
\+ QA-GNN (Ours) | 73.4 (+4.7) | 58.8 (+4.6)
| \+ QA-GNN (no edge
---
between Z and KG)
71.5 (+2.8) | 55.1 (+0.9)

Table 10: Performance on questions with negation in CommonsenseQA. () shows
the difference with RoBERTa. Existing LM+KG methods (KagNet, MHGRN) provide
limited improvements over RoBERTa (+0.6%); QA-GNN exhibits a bigger boost
(+4.6%), suggesting its strength in structured reasoning.

Table 10 compares model performance on questions containing negation words
(e.g., no, not, nothing, unlikely), taken from the CommonsenseQA IHtest set.
We find that previous LM+KG models (KagNet, MHGRN) provide limited
improvements over RoBERTa on questions with negation (+0.6%); whereas QA-GNN
exhibits a bigger boost (+4.6%), suggesting its strength in structured
reasoning. We hypothesize that QA-GNN’s joint updates of the representations
of the QA context and KG (during GNN message passing) allows the model to
integrate semantic nuances expressed in language. To further study this
hypothesis, we remove the connections between $z$ and KG nodes from our QA-GNN
(Table 10 bottom): now the performance on negation becomes close to the prior
work, MHGRN, suggesting that the joint message passing helps for performing
structured reasoning.

##### Qualitative analysis.

Figure 5 shows a case study to analyze our model’s behavior for structured
reasoning. The question on the left contains negation “not used for hair”, and
the correct answer is “B. art supply”. We observe that in the 1st layer of QA-
GNN, the attention from $z$ to question entities (“hair”, “round brush”) is
diffuse. After multiples rounds of message passing on the working graph, $z$
attends strongly to “round brush” in the final layer of the GNN, but weakly to
the negated entity “hair”. The model correctly predicts the answer “B. art
supply”. Next, given the original question on the left, we (a) drop the
negation or (b) modify the topic entity (“hair” $\\!\rightarrow\\!$ “art”). In
(a), $z$ now attends strongly to “hair”, which is not negated anymore. The
model predicts the correct answer “A. hair brush”. In (b), we observe that QA-
GNN recognizes the same structure as the original question (with only the
entity swapped): $z$ attends weakly to the negated entity (“art”) like before,
and the model correctly predicts “A. hair brush” over “B. art supply”.

Table 9 shows additional examples, where we compare QA-GNN’s predictions with
the LM baseline (RoBERTa). We observe that RoBERTa tends to make the same
prediction despite the modifications we make to the original questions (e.g.,
drop/insert negation, change an entity); on the other hand, QA-GNN adapts
predictions to the modifications correctly (except for double negation in the
table bottom, which is a future work).

####  4.6.4 Effect of KG node relevance scoring

Methods | IHtest-Acc. | IHtest-Acc.
---|---|---
| (Question w/
---
$\leq$ 10 entities)
| (Question w/
---
$>$ 10 entities)
RoBERTa-large (w/o KG) | 68.4 | 70.0
\+ MHGRN | 71.5 | 70.1
| \+ QA-GNN (w/o node
---
relevance score)
72.8 (+1.3) | 71.5 (+1.4)
| \+ QA-GNN (w/ node
---
relevance score; final system)
 73.4 (+1.9) | 73.5 (+3.4)

Table 11: Performance on questions with fewer / more entities in
CommonsenseQA. () shows the difference with MHGRN (LM+KG baseline). KG node
relevance scoring (§3.2) boosts the performance on questions containing more
entities (i.e. larger retrieved KG).

We find that KG node relevance scoring (§3.2) is helpful when the retrieved KG
($\mathcal{G}_{\text{sub}}$) is large. Table 11 shows model performance on
questions containing fewer ($\leq$10) or more (>10) entities in the
CommonsenseQA IHtest set (on average, the former and latter result in 90 and
160 nodes in $\mathcal{G}_{\text{sub}}$, respectively). Existing LM+KG models
such as MHGRN achieve limited performance on questions with more entities due
to the size and noisiness of retrieved KGs: 70.1% accuracy vs 71.5% accuracy
on questions with fewer entities. KG node relevance scoring mitigates this
bottleneck, reducing the accuracy discrepancy: 73.5% and 73.4% accuracy on
questions with more / fewer entities, respectively.

##  5 Related work and discussion

##### Knowledge-aware methods for NLP.

Various works have studied methods to augment natural language processing
(NLP) systems with knowledge. Existing works Pan et al. (2019); Ye et al.
(2019); Petroni et al. (2019); Bosselut et al. (2019) study pre-trained LMs’
potential as latent knowledge bases. To provide more explicit and
interpretable knowledge, several works integrate structured knowledge (KGs)
into LMs Mihaylov and Frank (2018); Lin et al. (2019); Wang et al. (2019a);
Yang et al. (2019); Wang et al. (2020b); Bosselut et al. (2021).

##### Question answering with LM+KG.

In particular, a line of works propose LM+KG methods for question answering.
Most closely related to ours are works by Lin et al. (2019); Feng et al.
(2020); Lv et al. (2020). Our novelties are (1) the joint graph of QA context
and KG, on which we mutually update the representations of the LM and KG; and
(2) language-conditioned KG node relevance scoring. Other works on scoring or
pruning KG nodes/paths rely on graph-based metrics such as PageRank,
centrality, and off-the-shelf KG embeddings Paul and Frank (2019); Fadnis et
al. (2019); Bauer et al. (2018); Lin et al. (2019), without reflecting the QA
context.

##### Other QA tasks.

Several works study other forms of question answering tasks, e.g., passage-
based QA, where systems identify answers using given or retrieved documents
Rajpurkar et al. (2016); Joshi et al. (2017); Yang et al. (2018), and KBQA,
where systems perform semantic parsing of a given question and execute the
parsed queries on knowledge bases (Berant et al., 2013; Yih et al., 2016; Yu
et al., 2018). Different from these tasks, we approach question answering
using knowledge available in LMs and KGs.

##### Knowledge representations.

Several works study joint representations of external textual knowledge (e.g.,
Wikipedia articles) and structured knowledge (e.g., KGs) Riedel et al. (2013);
Toutanova et al. (2015); Xiong et al. (2019); Sun et al. (2019); Wang et al.
(2019b). The primary distinction of our joint graph representation is that we
construct a graph connecting each question and KG rather than textual and
structural knowledge, approaching a complementary problem to the above works.

##### Graph neural networks (GNNs).

GNNs have been shown to be effective for modeling graph-based data. Several
works use GNNs to model the structure of text Yasunaga et al. (2017); Zhang et
al. (2018); Yasunaga and Liang (2020) or KGs Wang et al. (2020a). In contrast
to these works, QA-GNN jointly models the language and KG. Graph Attention
Networks (GATs) Veličković et al. (2018) perform attention-based message
passing to induce graph representations. We build on this framework, and
further condition the GNN on the language input by introducing a QA context
node (§3.1), KG node relevance scoring (§3.2), and joint update of the KG and
language representations (§3.3).

##  6 Conclusion

We presented QA-GNN, an end-to-end question answering model that leverages LMs
and KGs. Our key innovations include (i) Relevance scoring, where we compute
the relevance of KG nodes conditioned on the given QA context, and (ii) Joint
reasoning over the QA context and KGs, where we connect the two sources of
information via the working graph, and jointly update their representations
through GNN message passing. Through both quantitative and qualitative
analyses, we showed QA-GNN’s improvements over existing LM and LM+KG models on
question answering tasks, as well as its capability to perform interpretable
and structured reasoning, e.g., correctly handling negation in questions.

## Acknowledgment

We thank Rok Sosic, Weihua Hu, Jing Huang, Michele Catasta, members of the
Stanford SNAP, P-Lambda and NLP groups and Project MOWGLI team, as well as our
anonymous reviewers for valuable feedback. We gratefully acknowledge the
support of DARPA under Nos. N660011924033 (MCS); Funai Foundation Fellowship;
ARO under Nos. W911NF-16-1-0342 (MURI), W911NF-16-1-0171 (DURIP); NSF under
Nos. OAC-1835598 (CINES), OAC-1934578 (HDR), CCF-1918940 (Expeditions),
IIS-2030477 (RAPID); Stanford Data Science Initiative, Wu Tsai Neuro-sciences
Institute, Chan Zuckerberg Biohub, Amazon, JP-Morgan Chase, Docomo, Hitachi,
JD.com, KDDI, NVIDIA, Dell, Toshiba, and United Health Group. Hongyu Ren is
supported by Masason Foundation Fellowship and the Apple PhD Fellowship. Jure
Leskovec is a Chan Zuckerberg Biohub investigator.

## Reproducibility

Code and data are available at
https://github.com/michiyasunaga/qagnn.
Experiments are available at
https://worksheets.codalab.org/worksheets/0xf215deb05edf44a2ac353c711f52a25f.

## References

  * Banerjee and Baral (2020) Pratyay Banerjee and Chitta Baral. 2020.  Knowledge fusion and semantic knowledge ranking for open domain question answering.  _arXiv preprint arXiv:2004.03101_.
  * Banerjee et al. (2019) Pratyay Banerjee, Kuntal Kumar Pal, Arindam Mitra, and Chitta Baral. 2019.  Careful selection of knowledge to solve open book question answering.  In _Association for Computational Linguistics (ACL)_.
  * Bao et al. (2016) Junwei Bao, Nan Duan, Zhao Yan, Ming Zhou, and Tiejun Zhao. 2016.  Constraint-based question answering with knowledge graph.  In _International Conference on Computational Linguistics (COLING)_.
  * Bauer et al. (2018) Lisa Bauer, Yicheng Wang, and Mohit Bansal. 2018.  Commonsense for generative multi-hop question answering tasks.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Berant et al. (2013) Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. 2013.  Semantic parsing on freebase from question-answer pairs.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Bodenreider (2004) Olivier Bodenreider. 2004.  The unified medical language system (UMLS): Integrating biomedical terminology.  _Nucleic acids research_.
  * Bollacker et al. (2008) Kurt Bollacker, Colin Evans, Praveen Paritosh, Tim Sturge, and Jamie Taylor. 2008\.  Freebase: a collaboratively created graph database for structuring human knowledge.  In _SIGMOD_.
  * Bordes et al. (2013) Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. 2013.  Translating embeddings for modeling multi-relational data.  In _Advances in Neural Information Processing Systems (NeurIPS)_.
  * Bosselut et al. (2021) Antoine Bosselut, Ronan Le Bras, and Yejin Choi. 2021.  Dynamic neuro-symbolic knowledge graph construction for zero-shot commonsense question answering.  In _Proceedings of the AAAI Conference on Artificial Intelligence_.
  * Bosselut et al. (2019) Antoine Bosselut, Hannah Rashkin, Maarten Sap, Chaitanya Malaviya, Asli Çelikyilmaz, and Yejin Choi. 2019.  Comet: Commonsense transformers for automatic knowledge graph construction.  In _Association for Computational Linguistics (ACL)_.
  * Clark et al. (2019) Peter Clark, Oren Etzioni, Daniel Khashabi, Tushar Khot, Bhavana Dalvi Mishra, Kyle Richardson, Ashish Sabharwal, Carissa Schoenick, Oyvind Tafjord, Niket Tandon, et al. 2019.  From’f’to’a’on the ny regents science exams: An overview of the aristo project.  _arXiv preprint arXiv:1909.01958_.
  * Devlin et al. (2019) Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019.  Bert: Pre-training of deep bidirectional transformers for language understanding.  In _North American Chapter of the Association for Computational Linguistics (NAACL)_.
  * Fadnis et al. (2019) Kshitij Fadnis, Kartik Talamadupula, Pavan Kapanipathi, Haque Ishfaq, Salim Roukos, and Achille Fokoue. 2019.  Heuristics for interpretable knowledge graph contextualization.  _arXiv preprint arXiv:1911.02085_.
  * Feng et al. (2020) Yanlin Feng, Xinyue Chen, Bill Yuchen Lin, Peifeng Wang, Jun Yan, and Xiang Ren. 2020.  Scalable multi-hop relational reasoning for knowledge-aware question answering.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Gentner (1983) Dedre Gentner. 1983.  Structure-mapping: A theoretical framework for analogy.  _Cognitive science_.
  * Guu et al. (2015) Kelvin Guu, John Miller, and Percy Liang. 2015.  Traversing knowledge graphs in vector space.  _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Ioffe and Szegedy (2015) Sergey Ioffe and Christian Szegedy. 2015.  Batch normalization: Accelerating deep network training by reducing internal covariate shift.  In _International conference on machine learning (ICML)_.
  * Jin et al. (2021) Di Jin, Eileen Pan, Nassim Oufattole, Wei-Hung Weng, Hanyi Fang, and Peter Szolovits. 2021.  What disease does this patient have? a large-scale open domain question answering dataset from medical exams.  _Applied Sciences_.
  * Joshi et al. (2017) Mandar Joshi, Eunsol Choi, Daniel S Weld, and Luke Zettlemoyer. 2017.  Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension.  In _Association for Computational Linguistics (ACL)_.
  * Kassner and Schütze (2020) Nora Kassner and Hinrich Schütze. 2020.  Negated and misprimed probes for pretrained language models: Birds can talk, but cannot fly.  In _Association for Computational Linguistics (ACL)_.
  * Khashabi et al. (2020) Daniel Khashabi, Tushar Khot, Ashish Sabharwal, Oyvind Tafjord, Peter Clark, and Hannaneh Hajishirzi. 2020.  Unifiedqa: Crossing format boundaries with a single qa system.  In _Findings of EMNLP_.
  * Lan et al. (2020) Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020.  Albert: A lite bert for self-supervised learning of language representations.  In _International Conference on Learning Representations (ICLR)_.
  * Lee et al. (2020) Jinhyuk Lee, Wonjin Yoon, Sungdong Kim, Donghyeon Kim, Sunkyu Kim, Chan Ho So, and Jaewoo Kang. 2020.  Biobert: a pre-trained biomedical language representation model for biomedical text mining.  _Bioinformatics_.
  * Lin et al. (2019) Bill Yuchen Lin, Xinyue Chen, Jamin Chen, and Xiang Ren. 2019.  Kagnet: Knowledge-aware graph networks for commonsense reasoning.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Liu et al. (2020a) Fangyu Liu, Ehsan Shareghi, Zaiqiao Meng, Marco Basaldella, and Nigel Collier. 2020a.  Self-alignment pretraining for biomedical entity representations.  _arXiv preprint arXiv:2010.11784_.
  * Liu et al. (2020b) Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. 2020b.  On the variance of the adaptive learning rate and beyond.  In _International Conference on Learning Representations (ICLR)_.
  * Liu et al. (2019) Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019.  Roberta: A robustly optimized bert pretraining approach.  _arXiv preprint arXiv:1907.11692_.
  * Lv et al. (2020) Shangwen Lv, Daya Guo, Jingjing Xu, Duyu Tang, Nan Duan, Ming Gong, Linjun Shou, Daxin Jiang, Guihong Cao, and Songlin Hu. 2020.  Graph-based reasoning over heterogeneous external knowledge for commonsense question answering.  In _Proceedings of the AAAI Conference on Artificial Intelligence_.
  * Ma et al. (2019) Kaixin Ma, Jonathan Francis, Quanyang Lu, Eric Nyberg, and Alessandro Oltramari. 2019.  Towards generalizable neuro-symbolic systems for commonsense question answering.  _arXiv preprint arXiv:1910.14087_.
  * Mihaylov et al. (2018) Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. 2018.  Can a suit of armor conduct electricity? a new dataset for open book question answering.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Mihaylov and Frank (2018) Todor Mihaylov and Anette Frank. 2018.  Knowledgeable reader: Enhancing cloze-style reading comprehension with external commonsense knowledge.  In _Association for Computational Linguistics (ACL)_.
  * Pan et al. (2019) Xiaoman Pan, Kai Sun, Dian Yu, Jianshu Chen, Heng Ji, Claire Cardie, and Dong Yu. 2019.  Improving question answering with external knowledge.  _arXiv preprint arXiv:1902.00993_.
  * Paul and Frank (2019) Debjit Paul and Anette Frank. 2019.  Ranking and selecting multi-hop knowledge paths to better predict human needs.  In _North American Chapter of the Association for Computational Linguistics (NAACL)_.
  * Petroni et al. (2019) Fabio Petroni, Tim Rocktäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. 2019.  Language models as knowledge bases?  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Raffel et al. (2020) Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. 2020.  Exploring the limits of transfer learning with a unified text-to-text transformer.  _Journal of Machine Learning Research (JMLR)_.
  * Rajpurkar et al. (2016) Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016.  Squad: 100,000+ questions for machine comprehension of text.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Ren et al. (2020) Hongyu Ren, Weihua Hu, and Jure Leskovec. 2020.  Query2box: Reasoning over knowledge graphs in vector space using box embeddings.  In _International Conference on Learning Representations (ICLR)_.
  * Ren and Leskovec (2020) Hongyu Ren and Jure Leskovec. 2020.  Beta embeddings for multi-hop logical reasoning in knowledge graphs.  In _Advances in Neural Information Processing Systems (NeurIPS)_.
  * Riedel et al. (2013) Sebastian Riedel, Limin Yao, Andrew McCallum, and Benjamin M Marlin. 2013.  Relation extraction with matrix factorization and universal schemas.  In _North American Chapter of the Association for Computational Linguistics (NAACL)_.
  * Santoro et al. (2017) Adam Santoro, David Raposo, David G Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. 2017.  A simple neural network module for relational reasoning.  In _Advances in Neural Information Processing Systems (NeurIPS)_.
  * Schlichtkrull et al. (2018) Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. 2018.  Modeling relational data with graph convolutional networks.  In _European Semantic Web Conference_.
  * Speer et al. (2017) Robyn Speer, Joshua Chin, and Catherine Havasi. 2017.  Conceptnet 5.5: An open multilingual graph of general knowledge.  In _Proceedings of the AAAI Conference on Artificial Intelligence_.
  * Srivastava et al. (2014) Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. 2014.  Dropout: A simple way to prevent neural networks from overfitting.  _Journal of Machine Learning Research (JMLR)_ , 15(1):1929–1958.
  * Sun et al. (2019) Haitian Sun, Tania Bedrax-Weiss, and William W Cohen. 2019.  Pullnet: Open domain question answering with iterative retrieval on knowledge bases and text.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Sun et al. (2018) Haitian Sun, Bhuwan Dhingra, Manzil Zaheer, Kathryn Mazaitis, Ruslan Salakhutdinov, and William W Cohen. 2018.  Open domain question answering using early fusion of knowledge bases and text.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Talmor et al. (2019) Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. 2019.  Commonsenseqa: A question answering challenge targeting commonsense knowledge.  In _North American Chapter of the Association for Computational Linguistics (NAACL)_.
  * Toutanova et al. (2015) Kristina Toutanova, Danqi Chen, Patrick Pantel, Hoifung Poon, Pallavi Choudhury, and Michael Gamon. 2015.  Representing text for joint embedding of text and knowledge bases.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Veličković et al. (2018) Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua Bengio. 2018.  Graph attention networks.  In _International Conference on Learning Representations (ICLR)_.
  * Wang et al. (2020a) Hongwei Wang, Hongyu Ren, and Jure Leskovec. 2020a.  Entity context and relational paths for knowledge graph completion.  _arXiv preprint arXiv:2002.06757_.
  * Wang et al. (2020b) Peifeng Wang, Nanyun Peng, Pedro Szekely, and Xiang Ren. 2020b.  Connecting the dots: A knowledgeable path generator for commonsense question answering.  _arXiv preprint arXiv:2005.00691_.
  * Wang et al. (2019a) Xiaoyan Wang, Pavan Kapanipathi, Ryan Musa, Mo Yu, Kartik Talamadupula, Ibrahim Abdelaziz, Maria Chang, Achille Fokoue, Bassem Makni, Nicholas Mattei, et al. 2019a.  Improving natural language inference using external knowledge in the science questions domain.  In _Proceedings of the AAAI Conference on Artificial Intelligence_.
  * Wang et al. (2019b) Xiaozhi Wang, Tianyu Gao, Zhaocheng Zhu, Zhiyuan Liu, Juanzi Li, and Jian Tang. 2019b.  Kepler: A unified model for knowledge embedding and pre-trained language representation.  _Transactions of the Association for Computational Linguistics (TACL)_.
  * Wishart et al. (2018) David S Wishart, Yannick D Feunang, An C Guo, Elvis J Lo, Ana Marcu, Jason R Grant, Tanvir Sajed, Daniel Johnson, Carin Li, Zinat Sayeeda, et al. 2018.  Drugbank 5.0: a major update to the drugbank database for 2018.  _Nucleic acids research_.
  * Xiong et al. (2019) Wenhan Xiong, Mo Yu, Shiyu Chang, Xiaoxiao Guo, and William Yang Wang. 2019.  Improving question answering over incomplete kbs with knowledge-aware reader.  In _Association for Computational Linguistics (ACL)_.
  * Xu et al. (2020) Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. 2020.  What can neural networks reason about?  In _International Conference on Learning Representations (ICLR)_.
  * Yang et al. (2019) An Yang, Quan Wang, Jing Liu, Kai Liu, Yajuan Lyu, Hua Wu, Qiaoqiao She, and Sujian Li. 2019.  Enhancing pre-trained language representations with rich knowledge for machine reading comprehension.  In _Association for Computational Linguistics (ACL)_.
  * Yang et al. (2018) Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William W Cohen, Ruslan Salakhutdinov, and Christopher D Manning. 2018.  Hotpotqa: A dataset for diverse, explainable multi-hop question answering.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Yasunaga and Liang (2020) Michihiro Yasunaga and Percy Liang. 2020.  Graph-based, self-supervised program repair from diagnostic feedback.  In _International Conference on Machine Learning (ICML)_.
  * Yasunaga et al. (2017) Michihiro Yasunaga, Rui Zhang, Kshitijh Meelu, Ayush Pareek, Krishnan Srinivasan, and Dragomir Radev. 2017.  Graph-based neural multi-document summarization.  In _Conference on Computational Natural Language Learning (CoNLL)_.
  * Ye et al. (2019) Zhi-Xiu Ye, Qian Chen, Wen Wang, and Zhen-Hua Ling. 2019.  Align, mask and select: A simple method for incorporating commonsense knowledge into language representation models.  _arXiv preprint arXiv:1908.06725_.
  * Yih et al. (2016) Wen-tau Yih, Matthew Richardson, Christopher Meek, Ming-Wei Chang, and Jina Suh. 2016.  The value of semantic parse labeling for knowledge base question answering.  In _Association for Computational Linguistics (ACL)_.
  * Yu et al. (2018) Tao Yu, Rui Zhang, Kai Yang, Michihiro Yasunaga, Dongxu Wang, Zifan Li, James Ma, Irene Li, Qingning Yao, Shanelle Roman, et al. 2018.  Spider: A large-scale human-labeled dataset for complex and cross-domain semantic parsing and text-to-sql task.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Zhang et al. (2018) Yuhao Zhang, Peng Qi, and Christopher D Manning. 2018.  Graph convolution over pruned dependency trees improves relation extraction.  In _Empirical Methods in Natural Language Processing (EMNLP)_.
  * Zhu et al. (2020) Chen Zhu, Yu Cheng, Zhe Gan, Siqi Sun, Thomas Goldstein, and Jingjing Liu. 2020\.  Freelb: Enhanced adversarial training for language understanding.  In _International Conference on Learning Representations (ICLR)_.