Explainable Conversational Question Answering over Heterogeneous Sources
  via Iterative Graph Neural Networks
In conversational question answering, users express their information needs
through a series of utterances with incomplete context. Typical ConvQA methods
rely on a single source (a knowledge base (KB), or a text corpus, or a set of
tables), thus being unable to benefit from increased answer coverage and
redundancy of multiple sources. Our method EXPLAIGNN overcomes these
limitations by integrating information from a mixture of sources with
user-comprehensible explanations for answers. It constructs a heterogeneous
graph from entities and evidence snippets retrieved from a KB, a text corpus,
web tables, and infoboxes. This large graph is then iteratively reduced via
graph neural networks that incorporate question-level attention, until the best
answers and their explanations are distilled. Experiments show that EXPLAIGNN
improves performance over state-of-the-art baselines. A user study demonstrates
that derived answers are understandable by end users.
Philipp Christmann, Rishiraj Saha Roy, Gerhard Weikum
Explainable Conversational Question Answering over Heterogeneous Sources via Iterative Graph Neural Networks

###### Abstract.

In conversational question answering, users express their information needs through a series of utterances with incomplete context. Typical ConvQA methods rely on a single source (a knowledge base (KB), _or_ a text corpus, _or_ a set of tables), thus being unable to benefit from increased answer coverage and redundancy of multiple sources. Our method Explaingnn overcomes these limitations by integrating information from a mixture of sources with user-comprehensible explanations for answers. It constructs a heterogeneous graph from entities and evidence snippets retrieved from a KB, a text corpus, web tables, _and_ infoboxes. This large graph is then iteratively reduced via graph neural networks that incorporate question-level attention, until the best answers and their explanations are distilled out. Experiments show that Explaingnn improves performance over state-of-the-art baselines. A user study demonstrates that derived answers are understandable by end users.

+
Footnote †: [

footnote]Footnote 1: Code, data, and demo at [https://explaigm.mpi-inf.mpg.de](https://explaigm.mpi-inf.mpg.de).

+
Footnote †: [

footnote]Footnote 2: Code, data, and demo at [https://explaigm.mpi-inf.mpg.de](https://explaigm.mpi-inf.mpg.de).

+
Footnote †: [

footnote]Footnote 3: Code, data, and demo at [https://explaigm.mpi-inf.mpg.de](https://explaigm.mpi-inf.mpg.de).

+
Footnote †: [

footnote]Footnote 4: Code, data, and demo at [https://explaigm.mpi-inf.mpg.de](https://explaigm.mpi-inf.mpg.de).

## 1. Introduction

**Motivation**. In conversational question answering (ConvQA), users issue a sequence of questions, and the ConvQA system computes crisp answers [39, 45, 47]. The main challenge in ConvQA systems is that inferring answers requires understanding the current context, since incomplete, ungrammatical and informal _follow-up questions_ make sense only when considering the conversation history so far.

Existing ConvQA models mostly focused on using either (i) a curated knowledge base (KB) [22, 23, 24, 26, 31, 51], or (ii) a text corpus [5, 17, 38, 39, 41], or (iii) a set of web tables [18, 33] as source to compute answers. These methods are not geared for tapping into multiple sources jointly, which is often crucial as one source could compensate for gaps in others. Consider the conversation:

\(q^{1}\)_: Who wrote the book Angels and Demons?_

\(a^{1}\): Dan Brown

\(q^{2}\): _the main character in his books?_

\(a^{2}\): Robert Langdon

\(q^{3}\): _who played him in the films?_

\(a^{3}\): Tom Hanks

\(q^{4}\): to which headquarters was robert flow in the book?

\(a^{4}\): CERN

\(q^{5}\): how long is the novel?

\(a^{5}\): 768 pages

\(q^{6}\): what about the movie?

\(a^{6}\): 2 h 18 min

Some of these questions can be conveniently answered using a KB (\(q^{1}\), \(q^{3}\)), tables (\(q^{5}\), \(q^{6}\)), or infoboxes (\(q^{1}\), \(q^{3}\)) as they ask about salient attributes of entities, and some via text sources (\(q^{2}\), \(q^{3}\), \(q^{4}\)) as they are more likely to be contained in book contents and discussion. However, none of these individual sources represents the whole information required to answer _all questions_ of this conversation.

Recently, there has been preliminary work on ConvQA over a mixture of input sources [9, 10]. This improves the recall for the QA system with higher _answer coverage_, and the partial _answer redundancy_ across sources helps improve precision.

**Limitations of state-of-the-art methods**. Existing methods for ConvQA over heterogeneous sources rely on neural sequence-to-sequence models to compute answers [9, 10]. However, this has two significant limitations: (i) sequence-to-sequence models are _not explainable_, as they only generate strings as outputs, making it infeasible for users to decide whether to trust the answer; (ii) sequence-to-sequence models require inputs to be cast into token sequences first. This loses insightful information on relationships between evidences [64]. Such inter-evidence connections can be helpful in separating relevant information from noise.

**Approach**. We introduce Explaingnn1 (EXPLAinable Conversational Question Answering over Heterogeneous Graphs via Iterative Graph Neural Networks), a flexible pipeline that can be configured for optimizing _performance, efficiency, and explainability_ for ConvQA systems over heterogeneous sources. The proposed method operates in three stages:

Footnote 1: Code, data, and demo at [https://explaigm.mpi-inf.mpg.de](https://explaigm.mpi-inf.mpg.de).

1. Derivation of a self-contained _structured representation (SR)_ of the user's information need (or intent) from the potentially incomplete input utterance and the conversational context, making the entities, relation, and expected answer type explicit.
2. Retrieval of relevant evidences and answer candidates from heterogeneous information sources: a curated KB, a text corpus, a collection of web tables, and infoboxes.
3. Construction of a graph from these evidences, as the basis for applying graph neural networks (GNNs). The GNNs are iteratively applied for computing the best answers and supporting evidences in a small number of steps.
A key novelty is that each iteration reduces the graph in size, and only the final iteration yields the answer and a small user-comprehensible set of explanatory evidences. Our overarching goal is to provide end-user _explain_ability to _GNN_ inference by _iteratively_ reducing the graph size, so that the final answers can indeed be claimed to be causal w.r.t. the remaining evidences, hence the name Explain.A to example of such GNN-based reduction is in Fig. 1.

**Contributions**. We make the following salient contributions:

* Proposing a new method for ConvQA over heterogeneous sources, with a focus on computing explainable answers.
* Devising a mechanism for iterative application of GNN inference to reduce such graphs until the best answers and their explanatory evidences are obtained.
* Developing an attention mechanism which ensures that during message passing only question-relevant information is spread over the local neighborhoods.

## 2. Concepts and Notation

We now introduce salient concepts and notation, that will help understand the remainder of the paper. Table 1 contains the important notation.

**Question**. A _question_\(q\) asks about _factoid_ information, like _Who wrote the book Angels and Demons_? (intent is explicit), or _How long is the novel?_ (intent is implicit).

**Answer**. An _answer_\(a\) to \(q\) can be an entity (like Tom Hanks), or a literal (like 768 pages).

**Conversation**. A _conversation_ is a sequence of questions and answers \(\langle q^{1},a^{1},q^{2},a^{2},\dots\rangle\). The initial question \(q^{1}\) is complete, i.e. makes the information need explicit. The follow-up questions \(q^{t}\) (\(t\)\(\sim\)1) may be incomplete, building upon the ongoing conversational history, therefore leaving context information implicit.

**Turn**. A conversation turn \(t\) comprises a \(\langle q^{t},a^{t}\rangle\) pair.

**Knowledge base**. A curated _knowledge base_ is defined as a set of facts. Each fact consists of a subject, a predicate, an object, and an optional series of \(\langle\)qualifier-predicate, qualifier-object\(\rangle\) pairs: \(\langle s\), \(p\), \(o\); \(qp_{1}\), \(q_{0}\); \(qp_{2}\), \(q_{02}\);....\(\rangle\). An example fact is: (Angels and Demons, cast member, Tom Hanks; character, Robert Langdon).

**Text corpus**. A _text corpus_ consists of a set of text documents.

**Table**. A _table_ is a structured form of representing information, and is typically organized into a grid of rows and columns. Individual rows usually record information corresponding to specific entities, while columns refer to specific attributes for these entities. The row-header, column-header, and the cell hold the entity name, attribute name, and the attribute value, respectively.

**Infobox**. An _infobox_ consists of several entries that are \(\langle\)attribute name, attribute value\(\rangle\) pairs, and provide salient information on a certain entity. An infobox can be perceived as a special instantiation of a table, recording information on a single entity, and consisting of exactly two columns and a variable number of rows.

**Evidence**. An _evidence_\(\epsilon\) is a short text snippet expressing factual information, and can be retrieved from a KB, a text corpus, a table, and an infobox. To be specific, _evidence_s are verbalized KB-facts, text-sentences, table-records, or infobox-entries.

Figure 1. Toy heterogeneous graph for answering \(q^{3}\), showing two pruning iterations. The graph is iteratively reduced by GNN inference to identify the key evidences. The subgraph surrounded by the blue dotted line is the result of the first iteration, while the green line indicates the graph after the second. From this smaller subgraph, the final answer (Tom Hanks) is inferred.
**Structured representation**. The _structured representation SR_(Kumar et al., 2017) for \(q\) is an intent-explicit version of the question. The SR represents the current question using four slots: (i) _context entity_, (ii) _question entity_, (iii) _relation_, (iv) _expected answer type_. This intent-explicit representation can be represented in linear form as a single string, using delimiters to separate slots (\(\uparrow\)' in our case). The SR for \(q^{\text{s}}\) is:

\[\begin{array}{l}\texttt{(Angels and Demons|Robert\_Langdon|}\\ \texttt{who played him in the films|human)}\end{array}\]

In this example, Angels and Demons is the context entity, Robert Langdon the question entity, who played him in the films the relation, and human the expected answer type. We consider a relaxed notion of relations, in the sense of not being tied to KB terminology that canonicalizes textual relations to predicates. This allows for softer matching in evidences, and answering questions for which the information cannot easily be represented by such predicates.

## 3. Overview

The architecture of Explaingnn (Fig. 2) follows the pipeline of Convusse(Kumar et al., 2017): (i) an intent-explicit structured representation (SR) of the current information need is generated, (ii) evidences are retrieved from heterogeneous sources, and (iii) this large set of relevant evidences is used for answering the question and providing explanatory evidences.

### Question understanding

We use (Kumar et al., 2017) and generate a structured representation (SR) capturing the complete intent in the current question and the conversational context (the SR was loosely inspired by literature on quantity queries (Kumar et al., 2017)). For generating SRs, we leverage a fine-tuned auto-regressive sequence-to-sequence model (BART (BART, 2017)).

**Preventing hallucination**. We propose a novel mechanism to avoid _hallucinations_(Sanderson, 2017) in SRs. For \(q^{\text{s}}\) of the running example, the trained model could generate Robert de Niro as the (topically unrelated) question entity of the output SR (Dan Brown|Robert de Niro|who played him in the films|human). This would lead the entire QA system astray.

The SR is supposed to represent the information need on the _surface level_, and therefore expected to use the vocabulary present in the input (the conversational history and current question). This makes it possible to identify hallucinations: output words that are absent from the entire conversation so far, indicate such a situation. To fix this, we generate the top-\(k\) SRs (\(k\)=10 in experiments), and choose the highest-ranked SR that does not include any hallucinated words. Note that the expected answer type is an exception here: it may, by design, not be present in the input. So we remove this slot before performing the hallucination check. Answer types are often not made explicit but substantially help the QA system (Kumar et al., 2017).

### Evidence retrieval

_KB evidences_ and entity disambiguations are obtained via running Clocq(Kumar et al., 2017) on the SR (without delimiters). _Text, table and infobox evidences_ are obtained by mapping the disambiguated KB-entities to Wikipedia pages, which are then parsed for extracting text-sentences, table-records, and infobox-entries corresponding to the respective entities. Evidences from KB, web tables, or infoboxes, being natively in (semi-)structured form, are then _verbalized_(Sanderson, 2017; Sanderson, 2017) into token sequences (as in (Kumar et al., 2017)). Examples can be seen inside Fig. 1, where each evidence is tagged with its source.

**Use of SR slot labels.** Convusse considers all entities in the SR during retrieval, regardless of the slot in which they appear. In contrast, Explaingnn _restricts_ the entities by retaining only those mentioned within the _context entity_ or _question entity_ slots. Evidences are then only retrieved for this restricted set of entities. This prunes noisy disambiguations in the relation and type slots.

## 4. Heterogeneous Answering

We first describe heterogeneous answering graph construction (Sec. 4.1). Next, we present the proposed question-aware GNN architecture, consisting of the encoder (Sec. 4.2), the message passing procedure (Sec. 4.3), the answer candidate scoring (Sec. 4.4), and the multi-task learning mechanism for GNN training (Sec. 4.5).

### Graph construction

Given the evidences retrieved in the previous stage, we construct a _heterogeneous answering graph_ that has two types of nodes: entities and evidences. The graph contains _textual information_ as entity labels and evidence texts, as well as the _connections_ between these

\begin{table}
\begin{tabular}{l l} \hline \hline
**Notation** & **Concept** \\ \hline \(q^{\text{s}}\), \(a^{\text{t}}\) & Question and answer at turn \(t\) \\ \(SR^{\text{t}}\) & Structured representation at turn \(t\) \\ \hline \(e,\epsilon\) & Entity, evidence \\ \(E,\mathcal{E}\) & Sets of entity nodes and evidence nodes in graph \\ \(\mathcal{N}(e)\) & Evidences in 1-hop neighborhood of entity \(e\) \\ \(\mathcal{N}(\epsilon)\) & Entities in 1-hop neighborhood of evidence \(\epsilon\) \\ \hline \(e,\epsilon,SR\) & Encoding of \(e\) / \(\epsilon\) / \(SR\) \\ \(e^{\text{t}}\), \(e^{\text{t}}\) & Encoding of \(e\) / \(\epsilon\) after \(l\) GNN layers \\ \(d\) & Encoding dimension \\ \(\alpha_{e,\epsilon},\alpha_{e}\) & SR-attention of \(e\) (\(e\)) for updating \(e\) (\(e\)) \\ \(m_{e},m_{e}\) & Aggregated messages passed to \(e\) / \(\epsilon\) \\ \(s_{e},s_{e}\) & Score for \(e\) / \(\epsilon\) \\ \(w_{e},w_{e}\) & Multi-task weight for answer / evidence score prediction \\ \(\mathcal{L}\), \(\mathcal{L}_{e}\), \(\mathcal{L}_{e}\) & Loss functions: total, entity relevance, evidence relevance \\ \hline \hline \end{tabular}
\end{table}
Table 1. Notation for salient concepts in Explaingnn.

Figure 2. An overview of the Explaingnn pipeline, illustrating the three main stages of the approach.
two kinds of nodes. Specifically, an entity node \(\mathbf{e}\) is connected to an evidence node \(\mathbf{e}\), if \(\mathbf{e}\) is mentioned in \(\mathbf{\epsilon}\). There are no direct edges between pairs of entities, or pairs of evidences. An example heterogeneous graph is shown in Fig. 1.

**Inducing connections between retrieved evidences**. Shared entities are the key elements that induce _relationships_ between the initial plain _set_ of retrieved evidences. So one requires entity markup on the verbalized evidences coming from the different sources, that are grounded to a KB for _canonicalization_. Note that during evidence verbalization, original formats are not discarded. Thus, for KB-facts, entity mappings are already known. For text, table, and infobox evidences from Wikipedia, we link anchor texts to their referenced entity pages. These are then mapped to their corresponding KB-entities. In absence of anchor texts, named entity recognition and disambiguation systems can be used (Han et al., 2017; Wang et al., 2018; Wang et al., 2018). Dates and years that appear in evidences are detected using regular expressions, and are added as entities to the graph as well. In Fig. 1, entity mentions are underlined within evidences.

### Node encodings

GNNs incrementally update node encodings within local neighborhoods, leveraging message passing algorithms. However, these node encodings have to be initialized first using an encoder.

**Evidence encodings**. For the initial encoding of the nodes, we make use of cross-encodings (Wang et al., 2018) (originally proposed for sentence pair classification tasks in (Krizhevsky et al., 2015)). The evidence text, concatenated with the SR, is fed into a pre-trained language model. By using SR-specific cross-encodings, we ensure that the node encodings capture the information relevant for the current question, as represented by the SR. The encodings obtained for the individual tokens are averaged, yielding the initial evidence encoding \(\mathbf{\epsilon^{0}}\in\mathbb{R}^{d}\).

**Entity encodings**. The entity encodings are derived analogously, using cross-encodings with the SR. We further append the KB-type of an entity to the entity label with a separator, before feeding the respective token sequence into the language model. Including entity types is beneficial, and often crucial, for the reasons below: (i) The cross-encoding can leverage the attention between the _expected answer type_ in the SR and the _entity type_, which can be viewed as a soft-matching between the two.

(ii) When there are multiple entities with the same label, the entity type may be a discriminating factor downstream for each of these entities (e.g., there are three entities of different types named "_Robert Langdon_" in Fig. 1).

(iii) For long-tail entities, the entity type can add decisive informative value to the plain entity label.

Analogous to evidence nodes, the encodings of individual tokens are averaged to obtain the entity encoding \(\mathbf{e^{0}}\in\mathbb{R}^{d}\).

**SR encoding**. The SR is also encoded via the language model, averaging the token encodings to obtain the SR encoding \(\mathbf{5R}\in\mathbb{R}^{d}\).

Note that the same language model is used for the initial encodings of evidences, entities and the SR. The parameters of this language model are updated during GNN training, to ensure that the encoder adapts to the syntactic structure of the SR.

### Message passing

The core part of the GNN is the _message passing_(Wang et al., 2018; Wang et al., 2018) procedure. In this step, information is propagated among neighboring nodes, leveraging the graph structure. Given our graph design, in each message passing step information is shared between evidences and the connected entities. Again, we aim to focus on question-relevant information (Bahdan et al., 2017; Chen et al., 2018), as captured by the SR, instead of spreading general information within the graph. Therefore, we propose to weight the messages of neighboring entities using a novel _attention mechanism_, that re-weights the messages by their question-relevance, or equivalently, their SR-relevance. This _SR-attention_ is computed by \(d^{\mathbf{e}}_{\mathbf{e},\mathbf{e}}\in\mathbb{R}\):

\[\alpha^{l}_{\mathbf{e},\mathbf{e}}=\underset{\mathcal{N}(\mathbf{\epsilon})}{\text{softmax}} \Big{(}\text{lin}^{l}_{\alpha_{\mathbf{e}}}(\mathbf{e}^{l-1})\cdot\mathcal{SR}\Big{)}= \frac{\text{lin}^{l}_{\alpha_{\mathbf{e}}}(\mathbf{e}^{l-1})\cdot\mathcal{SR}}{\sum \limits_{\mathbf{e}_{i}\in\mathcal{N}(\mathbf{\epsilon})}\text{lin}^{l}_{\alpha_{\mathbf{e }}}(\mathbf{e}^{l-1}_{i})\cdot\mathcal{SR}} \tag{1}\]

where we first project the entity encodings using a linear transformation \((\text{lin}^{l}_{\alpha_{\mathbf{e}}}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d})\), and then multiply with the SR encoding to obtain a score. The softmax function is then applied over all entities neighboring a respective evidence (\(\mathbf{e}_{i}\in\mathcal{N}(\mathbf{\epsilon})\)). Thus, an entity can obtain different SR-attention scores for each evidence, depending on the scores of other neighboring entities.

The messages passed to \(\mathbf{\epsilon}\) are then aggregated, weighted by the respective SR-attention, and projected using another linear layer:

\[\mathbf{m}^{l}_{\mathbf{e}}=\text{lin}^{l}_{m_{\mathbf{e}}}\bigg{(}\sum\limits_{\mathbf{e}\in \mathcal{N}(\mathbf{\epsilon})}\mathbf{a}^{l}_{\mathbf{e},\mathbf{e}}\cdot\mathbf{e}^{l-1}\bigg{)} \tag{2}\]

where \(\text{lin}^{l}_{m_{\mathbf{e}}}\) is the linear layer (\(\text{lin}^{l}_{m_{\mathbf{e}}}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d}\)).

The updated evidence encoding is then given by adding the evidence encoding from the previous layer (\(\mathbf{\epsilon}^{l-1}\)), and the messages passed from the neighbors (\(\mathbf{m}^{l}_{\mathbf{e}}\)), activated by a ReLU function:

\[\mathbf{\epsilon}^{l}=\text{ReLU}\big{(}\mathbf{m}^{l}_{\mathbf{e}}+\mathbf{\epsilon}^{l-1} \big{)} \tag{3}\]

The intuition here is that in each evidence update, the question-relevant information held by neighboring entities is passed on to an evidence, and then incorporated in its encoding.

The process for updating the entity encodings is analogous, but makes use of different linear transformation functions. The SR-attention \(\alpha^{l}_{\mathbf{e},\mathbf{e}}\) of evidences for an entity \(\mathbf{e}\) is obtained as follows:

\[\alpha^{l}_{\mathbf{e},\mathbf{e}}=\underset{\mathcal{N}(\mathbf{\epsilon})}{\text{softmax}} \Big{(}\text{lin}^{l}_{\alpha_{\mathbf{e}}}(\mathbf{\epsilon}^{l-1})\cdot\mathcal{SR} \Big{)} \tag{4}\]

where \(\text{lin}^{l}_{\alpha_{\mathbf{e}}}\) (\(\mathbb{R}^{d}\rightarrow\mathbb{R}^{d}\)) is the linear transformation function. Here, the softmax function is applied over all evidences surrounding the respective entity (i.e. \(\mathbf{e}_{i}\in\mathcal{N}(\mathbf{\epsilon})\)). Again, the messages passed to an entity \(\mathbf{e}\) are weighted by the respective SR-attention, and projected using a linear layer (\(\text{lin}^{l}_{m_{\mathbf{e}}}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d}\)):

\[\mathbf{m}^{l}_{\mathbf{e}}=\text{lin}^{l}_{m_{\mathbf{e}}}\bigg{(}\sum\limits_{\mathbf{e}\in \mathcal{N}(\mathbf{\epsilon})}\mathbf{a}^{l}_{\mathbf{e},\mathbf{e}}\cdot\mathbf{\epsilon}^{l-1} \bigg{)} \tag{5}\]

The updated entity encoding is then given by:

\[\mathbf{e}^{l}=\text{ReLU}\big{(}\mathbf{m}^{l}_{\mathbf{e}}+\mathbf{e}^{l-1}\big{)} \tag{6}\]

These message passing steps are repeated \(L\) times, i.e. the GNN has \(L\) layers. Within these layers the question-relevant information is spread over the graph. Basically, nodes in the graph learn about
their question relevance, based on the surrounding nodes and their relevance, and capture this information in their node encodings.

### Answer score prediction

Scoring answer candidates makes use of the node encodings obtained after \(L\) message passing steps. We model the answer prediction as a _node classification_ task (Krizhevsky et al., 2014; Krizhevsky et al., 2015; Krizhevsky et al., 2016), by computing an answer score for each entity node with consideration of their question relevance as captured within the node encodings. The computation of the answer score \(s_{e}\) is similar to the technique used for computing the SR-attention of an entity:

\[s_{e}=\text{softmax}_{E}\Big{(}\text{lin}_{e}(\mathbf{e}^{L})\cdot SR\Big{)} \tag{7}\]

We project the entity encoding using a linear layer (\(\text{lin}_{e}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d}\)), and multiply the projected encoding with the encoding of the SR. The softmax function is applied over all entity nodes (i.e. \(\mathbf{e}_{i}\in E\)).

### Multi-task learning

Our training data for the GNN consists of \(\langle\)graph, answer\(\rangle\) pairs. The gold answer is always an entity or a small set of entities. Consequently, the positive training data is sparse: there can be hundreds of entities in the graph but only one gold answer.

To better use our training data, we propose a _multi-task learning_ (MTL) (Krizhevsky et al., 2014; Krizhevsky et al., 2016) approach. Given a GNN, we pose two complementary node classification tasks: (i) the answer prediction, and (ii) the prediction of evidence relevance. Evidences connected to gold answers are viewed as relevant, and others as irrelevant. Our method learns to predict a relevance score \(s_{e}\) for each evidence node \(\epsilon\), analogous to the answer score prediction:

\[s_{e}=\text{softmax}_{e\in\mathcal{E}}\Big{(}\text{lin}_{e}(\mathbf{e}^{L})\cdot SR \Big{)} \tag{8}\]

where \(\mathcal{E}\) is the set of all evidence nodes (and \(\text{lin}_{e}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d}\)).

For both tasks, answer prediction and evidence prediction, we use binary-cross-entropy over the predicted scores as loss functions: \(\mathcal{L}_{e}\) and \(\mathcal{L}_{e}\), respectively. The final loss used for training the GNN is then defined as a weighted sum:

\[\mathcal{L}=w_{e}\cdot\mathcal{L}_{e}+w_{e}\cdot\mathcal{L}_{e} \tag{9}\]

where \(w_{e}\) and \(w_{e}\) are hyper-parameters to control the multi-task learning, and are chosen such that \(w_{e}+w_{e}=1\).

The described GNN architecture can then be trained for predicting scores of answer candidates and evidences, and used for inference on the whole input graphs in _one shot_.

## 5. Iterative graph neural networks

We now outline how we use trained GNNs for iteratively reducing the graph at inference time. Specifically, we comment on the benefits that such iterative GNNs have for robustness, explainability and efficiency.

**Drawbacks of a one-shot prediction**. There are several drawbacks of predicting the answer from the full graph _during inference_: (i) Directly predicting the answer from hundreds of answer candidates is non-trivial, and node classification may struggle to manifest fine-grained differences between such candidate answers in their encodings. This can negatively impact the _robustness_ of the method on unseen data.

(ii) Further, if the answer is predicted from the whole input graph at inference time, this means that all nodes in the graph contribute towards the answer prediction. Showing the whole graph, consisting of hundreds of nodes, to explain how the answer was derived is not practical. The SR-attention scores could be an indicator as to which nodes were more relevant, but attention is not always sufficient as an explanation (Krizhevsky et al., 2016). Hence, _answer explainability_ would be limited. (iii) Finally, obtaining cross-encodings for hundreds of nodes (entities and evidences) can be computationally expensive, affecting the _runtime efficiency_ of the system. A large fraction of these initial graph nodes might be rather irrelevant, which can often be identified using a more light-weight (i.e. more efficient) encoder.

**Iterative inference of GNNs**. To overcome these drawbacks, we propose _iterative GNNs_: instead of predicting the answer in one shot, we _iteratively apply trained GNNs_ of the outlined architecture _during inference_. The key idea is to shrink the graph after each iteration. This can be done via the evidence scores \(s_{e}\) predicted by the GNNs, to identify the most relevant evidences. These evidences, and the connected entities, are used to initiate the graph given as input to the next iteration. In the final iteration, the answer is predicted from the reduced graph only.

Fig. 3 illustrates training and inference with iterative GNNs. Note that these GNNs are still trained on the full graphs in the training data, and are run iteratively only at inference time. This iterative procedure is feasible as the proposed GNN architecture is inherently independent of the input graph size: the same GNN trained on 500 evidences can be applied on a graph with 100, 20, or 5 evidences. The GNNs essentially learn to spread question-relevant information within local neighborhoods, which is not only required for large graphs with hundreds of evidences, but also for smaller graphs with a handful of nodes. Further, this iterative procedure is tractable only with the flexibility of scoring both entities and evidences in the graph, using the same GNN architecture.

**Enhancing robustness**. Within each iteration, the task complexity is decreased compared to the task complexity the original GNN was trained on. For example, the GNN was originally trained for predicting small answer sets and relevant evidences from several hundreds of nodes, but in the iterative setup, rather needs to identify the top-100 evidences during inference. Thus, the GNN model now

Figure 3. Training of and inference with iterative GNNs.
has to be _less discriminatory_ at inference time than during training. This can help improve _robustness_.

**Facilitating explainability.** A primary benefit of the iterative mechanism is that the intermediate graphs can be used to better understand how answer prediction works via a GNN. Showing all the information contained in the original input graph with hundreds of entities and evidences to the user is not practical: we can iteratively derive a small set of evidences (say five), from which the answer is predicted. These evidences can then be presented to the end user, enhancing _user explainability_.

**Improving efficiency.** To facilitate the runtime _efficiency_ of the answering process, we refrain from encoding entities via cross-encodings in the _shrinking_ (or _pruning_) iterations. Instead, we initiate the entity encodings, using a sum of the surrounding evidences, weighted by their question-relevance (i.e. their SR-attention):

\[\mathbf{e}^{0}=\sum_{e\in\mathcal{N}(\mathbf{e})}\alpha_{\mathbf{e},e}\cdot\mathbf{e}^{0} \tag{10}\]

where the SR-attention \(\alpha_{\mathbf{e},e}\) is computed as in Eq. 1, employing a different linear projection. This can be perceived as obtaining _alternating encodings_ of entities: the initial evidence encodings are used to initialize entity encodings (inspired by (Beng et al., 2017)). The message passing would then proceed as outlined in Sec. 4.3.

**Instantiation.** We train several one-shot GNNs of the architecture outlined above, using different weights on the answer prediction and evidence relevance prediction tasks (\(w_{e}\) and \(w_{e}\) respectively) in the MTL setup. Further, we train GNNs using either cross-encodings or alternating encodings for entities. Training is conducted on the full input graphs present in the training set. We then simply instantiate all _pruning iterations_ with the GNN that obtains the best evidence prediction performance on the graphs in the development (dev) set. Similarly, we use the trained GNN that obtained the best answering performance on the dev set to initiate the final _answering iteration_. Finally, the answer predicted by the system is given by:

\[a_{pred}=\arg\max_{e\in\mathcal{E}}s_{e} \tag{11}\]

This is shown to the end user, together with the explanatory evidences \(\{\epsilon_{pred}\}\) (see outputs in Fig. 2), that are simply the set of evidences used in the answer prediction step.

## 6. Results and Insights

### Experimental setup

**Dataset**. We train and evaluate Explaingn on the ConvMix(Chen et al., 2017) benchmark, which was designed for ConvQA over heterogeneous information sources. The dataset has 16,000 questions (train: 8,400 questions, dev: 2,800 questions, test: 4,800 questions), within 3,000 conversations of five (2,800) or ten turns (200, only used for testing).

**Metrics**. For accessing the answer performance, we use _precision at 1_ (P@1), as suggested for the ConvMix benchmark. To investigate the ranking capabilities of different methods in more detail, we also measure the _mean reciprocal rank_ (**MRR**), and _hit at 5_ (**Hit@5**). The _answer presence_ **(Ans. pres.)** is the fraction of questions for which a gold answer is present in a given set of evidences.

**Baselines.** We compare Explaingn with the state-of-the-art method on the ConvMix dataset, Convinse(Chen et al., 2017). Convinse leverages a Fusion-in-Decoder (FiD) (Li et al., 2017) model for obtaining the top answer, which is designed to generate a single answer string. In (Chen et al., 2017), the ranked entity answers are then derived by collecting the top-\(k\) answer candidates with the highest surface-form match with respect to Levenshtein distance with the generated answer string. This procedure is somewhat limiting when measuring metrics beyond the first rank (i.e. MRR or Hit@5). Therefore, we enhanced the FiD model to directly generate top-\(k\) answer strings, and then consider the answer candidate with the highest surface-form match for each such generated string (**top-\(k\) FiD**), for fair comparison. We further compare with baselines proposed in (Chen et al., 2017) using question completion and resolution, and use the values reported in (Chen et al., 2017) for consistency. Note that these methods transform a conversational question to a self-sufficient form, and still need to be coupled with retrieval and answer generation modules.

**Configurations.** The QU and ER stages were initialized using the Convinse(Chen et al., 2017) code and data: we used Wikidata as the KB, and made use of the same version (31 January 2022) as earlier work. The Wikipedia evidences were taken from here2, whenever applicable, and retrieved on-the-fly otherwise. This ensures that results are comparable with the results provided in earlier work. ConvMix has \(\simeq\) 3% of yes/no questions: these are out of scope for Explaingn. To be able to report numbers on the full benchmark, we follow previous work (Chen et al., 2017) and detect such questions as starting with an auxiliary verb, and answer "yes" to these.

Footnote 2: [http://qa.mpi-inf.mpg.de/convinse/convmix_data/wikipedia.zip](http://qa.mpi-inf.mpg.de/convinse/convmix_data/wikipedia.zip)

The GNNs were implemented from scratch via PyTorch. We used DistilRoBERTa provided by Hugging Face3 as encoder, which we found to perform slightly better than DistilBERT (Wang et al., 2019) (the distillation procedure is the same). DistilRoBERTa has an embedding dimension of \(d\)=768. The GNNs were trained for 5 epochs. We chose an epoch-wise evaluation strategy, and kept the model that achieved the best performance on the dev set. We found three layer GNNs (\(L\)=3) most effective. With our graph schema of alternating entities and evidences, using an odd number of layers allows for information from evidences to reach relevant entities in their immediate (one hop) and slightly distant neighborhoods (three or five hops, say). AdamW was used as optimizer, using a learning rate of \(10^{-5}\), batch size of 1, and a weight decay of 0.01.

Footnote 3: [https://huggingface.co/distilroberta-base](https://huggingface.co/distilroberta-base)

We also used the dev set for choosing the number of GNN iterations, and MTL weights for pruning and answering. The number of iterations was set to \(i\)=3. The GNN that maintains the highest answer presence among the top-5 evidences was chosen for instantiating the pruning iterations (alternating encodings for entities, w\({}_{e}\)=0.3, w\({}_{e}\)=0.7), and the GNN obtaining the highest P@1 for the answer prediction (cross-encodings for entities, w\({}_{e}\)=0.5, w\({}_{e}\)=0.5). In case there are more than 500 evidences, we retain only the top-500 obtained via BM25 scoring as input to the answering stage. A single GPU (WVIDIA Quadro RTX 8000, 48 GB GDDR6) was used to train and evaluate the models.

### Key findings

This section will present the main experimental results on the ConvMix test set. All provided metrics are averaged over all _questions_ in the dataset. The best method for each column is shown in **bold**. Statistical significance over the best baseline is indicated by an asterisk
(*), and is measured via paired \(t\)-tests for MRR, and McNemar's test for binary variables (P@1 or Hit@5), with \(p<0.05\) in both cases.

**Explaignn improves the answering performance.** The main results in Table 2 demonstrate the performance benefits of Explaingnn over the baselines. Explaingnn significantly outperforms the best baseline on all metrics, illustrating the success of using _iterative graph neural networks_ in ConvQA. As is clear from the method descriptions in Table 2, all baselines crucially rely on the generative reader model of FiD. FiD can ingest multiple evidences to produce the answer, but fails to capture their relationships explicitly, that is unique to our graph-based pipeline. Our adaptation of using top-\(k\) FiD instead of the default top-1 improved the ranking capabilities (MRR, Hit@5) of the strongest baseline Convinse. However, Explaingnn still substantially improved over Convinse with top-\(k\) FiD.

**Explaignn is robust to wrong predictions in earlier turns.** Unlike many existing works, we also evaluated the methods in a _realistic scenario_, in which the predicted answers \(a_{pred}\) are used as (noisy) input for the conversational history instead of the standard yet impractical choice of inserting gold answers from the benchmark. Results are shown in Table 3 (cf. Table 2 results, that show an evaluation with gold answers). While the performance of all methods drops in this more challenging setting, the trends are very similar, indicating that Explaingnn can successfully overcome failures (i.e. incorrect answer predictions) in earlier turns. Explaingnn again outperforms all baselines significantly, including a P@1 jump from \(0.279\) for the strongest baseline to \(0.339\).

**Heterogeneous sources improve performance.** Analysis of source combinations is in Table 4. The first takeaway is that the answering performance was the best when the full spectrum of sources was used. Explaingnn can make use of the enhanced answer presence in this case, and answer more questions correctly. Next, the results indicate that adding an information source is always beneficial: the performance of combinations of two sources is in all cases better than for the two sources individually.

### In-depth analysis

**Multi-task learning enables flexibility.** A systematic analysis of the effect of different multi-task learning weights is shown in Table 5. This analysis is conducted on the dev set, for choosing the best GNN for pruning and answering, respectively. Entities are either encoded via cross-encodings, or alternating encodings (see Eq. 10). The results indicate the runtime benefits of using alternating encodings for entities. Further, when optimized for evidence relevance prediction (\(w_{e}>0.5\)) it can maintain a high answer presence (measured within top-5 evidences), indicating that light-weight encoders are indeed sufficient for the pruning iterations. Further, we found putting equal weights on the answer and evidence relevance prediction to be beneficial for answering.

**Iterative GNNs do not compromise runtimes.** Table 6 reports results of varying the number of iterations \(i\in\{1,2,3,4\}\), and the graph size in the number of evidences the answer is predicted from \((|\mathcal{E}|\in\{500,100,50,20,5\})\). For each row, the reduction in graph size in terms of the number of evidences considered was kept roughly constant for consistency. By our smart use of alternating encodings of entities in the pruning iterations, _runtimes remain immune_ to the number of pruning iterations (times for \(i\)=4 are not necessarily higher than those for \(i\)=3, and so on). Rather, the runtime is primarily influenced by the size of the graph (in terms of the number of evidences) given to the final answer prediction

\begin{table}
\begin{tabular}{l|c c c|c} \hline \hline
**Method \(\downarrow\)** & **P@1** & **MRR** & **Hit@5** & **Ans. pres.** \\ \hline
**KB** & 0.363 & 0.427 & 0.511 & 0.617 \\
**Text** & 0.233 & 0.300 & 0.380 & 0.530 \\
**Tables** & 0.064 & 0.084 & 0.108 & 0.155 \\
**Infoboxes** & 0.256 & 0.302 & 0.362 & 0.409 \\ \hline
**KB+Text** & 0.399 & 0.464 & 0.549 & 0.672 \\
**KB+Tables** & 0.363 & 0.429 & 0.515 & 0.629 \\
**KB+Infoboxes** & 0.376 & 0.443 & 0.532 & 0.640 \\
**Text+Tables** & 0.235 & 0.305 & 0.392 & 0.540 \\
**Text+Infoboxes** & 0.309 & 0.369 & 0.445 & 0.572 \\
**Tables+Infoboxes** & 0.263 & 0.312 & 0.374 & 0.453 \\ \hline \hline
**All sources** & **0.406** & **0.471** & **0.561** & **0.683** \\ \hline \hline \end{tabular}
\end{table}
Table 4. Effect of varying source combinations at inference time (test set). Explaingnn is still _trained_ on all sources.

\begin{table}
\begin{tabular}{l|c c c} \hline \hline
**Method \(\downarrow\)** & **P@1** & **MRR** & **Hit@5** \\ \hline
**Q. Resolution**(Spi and Welling, 2017) & 0.282 & 0.289 & 0.297 \\
**Q. Rewriting**(Spi and Welling, 2017) & 0.271 & 0.278 & 0.285 \\
**Convinse(Spi and Welling, 2017)** & 0.342 & 0.365 & 0.386 \\
**Convinse(Spi and Welling, 2017)** & 0.343 & 0.378 & 0.431 \\ \hline
**Explaignn (proposed)** & **0.406\({}^{*}\)** & **0.471\({}^{*}\)** & **0.561\({}^{*}\)** \\ \hline \hline \end{tabular}
\end{table}
Table 2. Comparison of answering performance on the ConvMix (Spi and Welling, 2017) test set, using _gold answers_\(\{a_{gold}\}\) in the history.

\begin{table}
\begin{tabular}{l|c c c} \hline \hline
**Method \(\downarrow\)** & **P@1** & **MRR** & **Hit@5** \\ \hline
**Q. Resolution**(Spi and Welling, 2017) + BM25 + FiD(Hit et al., 2017) & 0.282 & 0.289 & 0.297 \\
**Q. Rewriting**(Spi and Welling, 2017) + BM25 + FiD(Hit et al., 2017) & 0.271 & 0.278 & 0.285 \\
**Convinse(Spi and Welling, 2017)** & 0.342 & 0.365 & 0.386 \\
**Convinse(Spi and Welling, 2017)** (top-\(k\) FiD)** & 0.343 & 0.378 & 0.431 \\ \hline
**Explaignn (proposed)** & **0.406\({}^{*}\)** & **0.471\({}^{*}\)** & **0.561\({}^{*}\)** \\ \hline \hline \end{tabular}
\end{table}
Table 3. Comparison of answering performance on the ConvMix test set, using _predicted answers_\(\{a_{pred}\}\) in the history.
step (compare runtimes within each iteration group). Recall that this graph size for answer prediction can impact _explainability_ to end users, if it is not small enough. Notably, _performance_ remains reasonably stable in most cases. A key takeaway from these results is that the trained GNN models generalize well to graphs of different sizes. Concretely, while all of these models are trained on graphs established from 500 evidences, they can be applied to score nodes in graphs of variable sizes.

**Explaignn can be applied zero-shot**. For testing the generalizability of Explaingnn, we applied the pipeline trained on the ConvMix dataset out-of-the-box, without any training or fine-tuning, on the ConvQuestions(Chen et al., 2017) dataset. ConvQuestions is a competitive benchmark for ConvQA methods operating over KBs. We test the same Explaingnn pipeline in two different modes: (i) using only facts from the KB, and (ii) using evidences from all information sources. Table 7 shows the results (\({}^{\dagger}\) and \({}^{\ddagger}\) indicate statistical significance over the leaderboard toppers Krr (Zhu et al., 2017) and Praline(Praline, 2017), respectively). In the KB-only setting, Explaingnn obtains state-of-the-art performance, reaching the highest MRR score. Also, we found that integrating heterogeneous sources can improve the answer performance substantially for ConvQuestions, even though this benchmark was created with a KB in mind.

**Iterative GNNs improve robustness**. In Sec. 4, we argued that iterative GNNs enhance the pipeline's robustness over a single GNN applied on the full graph in one shot. While the performance of the one-shot GNN on the ConvMix dev set is comparable (Table 6), we found that it cannot generalize as well to a different dataset. When applied on ConvQuestions, the respective performance of the one-shot GNN is significantly lower than for Explaingnn, in both KB-only (P@1 : 0.330 versus 0.281) and heterogeneous (P@1 : 0.363 versus 0.318) settings.

**SR-attention, cross-encoding and entity types are crucial**. Table 8 shows results (\({}^{\dagger}\) indicates significant performance drop) of our ablation study. We found that each of these mechanisms helps the pipeline to improve QA performance. The most decisive factor is the SR-attention (Sec. 4.3), which ensures that only the question-relevant information is spread within the local neighborhoods: without this component, the performance drops substantially (P@1 from 0.442 to 0.062). Similarly, the cross-encodings (Sec. 4.2) initialize the nodes with question-relevant encodings. Also notable is the crucial role of entity types (Sec. 4.2), that help suppress irrelevant answer candidates with mismatched answer types.

**Error analysis**. We identified three key sources of error: (i) the answer is not present in the initial graph (53.9% of error cases), which can be mitigated by improving the QU and ER stages of the pipeline, (ii) the answer is dropped when shrinking the graph (8.1%), and (iii) the answer is present in the final graph but not identified as the correct answer (38.0%). The graph shrinking procedure is responsible for only a few errors (2.2% in the first iteration, 5.9% in second), demonstrating the viability of our iterative approach.

## 7. User Study on Explainability

We evaluate the explainability of our pipeline by a user study on Amazon Mechanical Turk (AMT). The use case scrutinized here is that a user has an information need, obtains the answer predicted by the system, and is unsure whether to trust the provided answer. Thus, the key objective of the explanations in this work is to help

\begin{table}
\begin{tabular}{l c c c c c c} \hline \hline
**Method \(\downarrow\)** & **P@1** & **MRR** & **Hit@5** & **Ans. pres. and no. of evidences after pruning iteration** & **HA runtime** \\ \hline
**Explaignn** (\(i\)=1: 500\(\rightarrow\)4\({}_{pred}\)) & 0.442 & 0.502 & 0.581 & – & – & - & 1,017 ms \\ \hline
**Explaignn** (\(i\)=2: 500\(\rightarrow\)100\(\rightarrow\)4\({}_{pred}\)) & 0.441 & 0.504 & 0.587 & – & – & 0.687 100 & 744 ms \\
**Explaignn** (\(i\)=2: 500\(\rightarrow\)50\(\rightarrow\)4\({}_{pred}\)) & 0.440 & 0.504 & 0.588 & – & – & 0.675 50 & 591 ms \\
**Explaignn** (\(i\)=2: 500\(\rightarrow\)20\(\rightarrow\)4\({}_{pred}\)) & 0.438 & 0.504 & 0.591 & – & – & 0.655 20 & 515 ms \\
**Explaignn** (\(i\)=2: 500\(\rightarrow\)5\(\rightarrow\)4\({}_{pred}\)) & 0.422 & 0.480 & 0.560 & – & – & 0.589 5 & 459 ms \\ \hline
**Explaignn** (\(i\)=3: 500\(\rightarrow\)200\(\rightarrow\)100\(\rightarrow\)4\({}_{pred}\)) & 0.441 & 0.504 & 0.585 & – & 0.694 200 & 0.685 100 & 995 ms \\
**Explaignn** (\(i\)=3: 500\(\rightarrow\)150\(\rightarrow\)50\(\rightarrow\)4\({}_{pred}\)) & 0.441 & **0.505** & 0.586 & – & 0.693 150 & 0.678 50 & 741 ms \\
**Explaignn** (\(i\)=3: 500\(\rightarrow\)100\(\rightarrow\)20\(\rightarrow\)4\({}_{pred}\); **proposed)** & **0.442** & **0.505** & 0.589 & – & 0.687 100 & 0.654 20 & 20 & 601 ms \\
**Explaignn** (\(i\)=3: 500\(\rightarrow\)50\(\rightarrow\)5\(\rightarrow\)4\({}_{pred}\)) & 0.419 & 0.475 & 0.556 & – & 0.675 50 & 0.579 5 & 511 ms \\ \hline
**Explaignn** (\(i\)=4: 500\(\rightarrow\)300\(\rightarrow\)150\(\rightarrow\)100\(\rightarrow\)4\({}_{pred}\)) & 0.441 & 0.504 & 0.587 & 0.696 300 & 0.691 150 & 0.686 100 & 1,232 ms \\
**Explaignn** (\(i\)=4: 500\(\rightarrow\)200\(\rightarrow\)100\(\rightarrow\)50\(\rightarrow\)4\({}_{pred}\)) & 0.440 & 0.504 & 0.585 & 0.694 200 & 0.685 100 & 0.677 50 & 50 & 945 ms \\
**Explaignn** (\(i\)=4: 500\(\rightarrow\)200\(\rightarrow\)50\(\rightarrow\)20\(\rightarrow\)4\({}_{pred}\)) & 0.436 & 0.500 & 0.584 & 0.694 200 & 0.677 50 & 0.652 20 & 769 ms \\
**Explaignn** (\(i\)=4: 500\(\rightarrow\)100\(\rightarrow\)20\(\rightarrow\)5\(\rightarrow\)4\({}_{pred}\)) & 0.422 & 0.476 & 0.553 & 0.687 100 & 0.654 20 & 20 & 0.575 5 & 577 ms \\ \hline \hline \end{tabular}
\end{table}
Table 6. Varying the no. of iterations, pruning factors, and evidences the answer is predicted from _during inference_ (dev set).

\begin{table}
\begin{tabular}{l|c c c} \hline \hline
**Method \(\downarrow\)** & **P@1** & **MRR** & **Hit@5** \\ \hline
**Convex (Chen et al., 2017)** & 0.184 & 0.200 & 0.219 \\
**Focal Entity Model (Zhu et al., 2017)** & 0.248 & 0.248 & 0.248 \\
**Oat (Chen et al., 2017)** & 0.166 & 0.175 & – \\
**Oat (Chen et al., 2017)** (w/ gold seed entities)** & 0.250 & 0.260 & – \\
**Conquer (Chen et al., 2017)** & 0.240 & 0.279 & 0.329 \\
**Praline (Praline, 2017)** & 0.294 & 0.373 & 0.464 \\
**Krr (Zhu et al., 2017)** (w/ gold seed entities)** & **0.397** & 0.397 & 0.397 \\ \hline
**Explaignn** (KB-only) & 0.330\({}^{\ddagger}\) & **0.399\({}^{\ddagger}\)** & **0.480\({}^{\ddagger}\)** \\
**Explaignn** & 0.363\({}^{\ddagger}\) & **0.447\({}^{\dagger\ddagger}\)** & **0.546\({}^{\ddagger}\)** \\ \hline \hline \end{tabular}
\end{table}
Table 7. Out-of-the-box Explaingnn, without further training or fine-tuning, on the ConvQuestions(Chen et al., 2017) benchmark.
the user decide whether to trust the answer. If the user is able to make this decision easily, the explanations serve their purpose.

**User study design.** For a predicted answer to a conversational question, the user is given the conversation history, the current question, the SR, and the explaining evidences. Examples of the input presented to the user are shown in Fig. 9 and Fig. 10 (we used five explanatory evidences). The user then has to decide whether the provided answer is correct. We randomly sample 1,200 instances on which we measure user accuracy. One of our main considerations during sampling was that one half (600) was correctly answered and the other half (600) incorrectly answered by Explaingn.

**User study interface**. For each instance, we then ask Turkers the following questions: (i) _"Do you think that the provided answer is correct?"_ (**User correctness**), (ii) _"Are you certain about your decision?"_ (**User certainty**), and (iii) _"Why are you certain about the decision?"_ or _"Why are you uncertain about the decision?"_. The first two questions can be answered by either _"Yes"_, or _"No"_. Depending on the answer to the second question, the third question asks for reasons for their (un)certainty. The user can select multiple provided options. If the user is certain, these options are either _good explanation_, _prior knowledge_, and _common sense_. If the user is uncertain, then she must choose between _bad explanation_ or _question_/_conversation unclear_. The idea is to remove confounding cases in which users make a decision regardless of the provided explanation, since we cannot infer much from these. Note that Turkers were not allowed to access external sources like web search.

**Quality control**. For quality control, we restrict the participation in our user study to Master Turkers with an approval rate of \(\geq\)95%. Further, we added honeypot questions, for which the answer and provided information are clearly irrelevant with respect to the question (domain and answer type mismatch), We excluded submissions from workers who gave incorrect responses to the honeypots.

**Explaignn provides explainable answers**. Findings are presented as a confusion matrix in Table 11 (values computed after removing confounding assessments). In the 771 of the 1,200 observations that remain, we found that the user can accurately decide

\begin{table}
\begin{tabular}{l l} \hline \hline
**Answer correctness** (Correctness of the provided answer) & \(\checkmark\) **Answer correctness** (Correctness of the provided answer) & \(\checkmark\) **Predicted correctness** (User assessment of the answer correctness) & \(\checkmark\) **Predicted correctness** (User assessment of the answer correctness) & \(\checkmark\) **User correctness** \\
**User correctness** (Correctness of the user assessment) & \(\checkmark\) **User correctness** (Correctness of the user assessment) & \(\checkmark\) **User correctness** (Correctness of the user assessment) & \(\checkmark\) **User correctness** (Correctness of the user assessment) & \(\checkmark\) **User certainty** (User certainty about her assessment) & \(\checkmark\) **User truth** \\ \hline
**User certainty** (User certainty about her assessment) & \(\checkmark\) **User certainty** (User certainty about her
the correctness of the system answer (76.1%) and is certain about their assessment (79.8%) most of the time. This proves that our explanations are indeed useful to end users. If the user is certain about their assessment, then we observed that the accuracy in deciding the correctness was higher: P(User correct | User certain) = 0.792.

**Anecdotal examples**. Fig. 9 and Fig. 10 show example outputs of Explaingnn, and the corresponding results from the user study. For the examples in Fig. 9 the Explaingnn answer was _correct_. Based on the explanation (system interpretation and supporting evidences) the users could _certainly_ tell the correctness of the answer. For the examples in Fig. 10, the answer provided by Explaingnn was _incorrect_. In the first case, the user was able to identify this incorrectness _with certainty_ from the explanation (the first and second supporting evidences mention that Allison Janney played Bonnie Plunkett, and not Christy Plunkett). The user could then try to reformulate (Les and Plunkett, 2018) the question to obtain the correct answer. In the second case, the provided information was not sufficient, since there is no information on the club Rivaldo played for in 1999. So the user was _uncertain_ about the answer correctness. Note that even in this scenario the end user would understand that the provided answer needs to be verified. This is in contrast to incorrect answers generated by large language models, which often look perfect on surface, giving the user a false sense of correctness.

The guidelines, code, and the results for the user study are publicly available4.

Footnote 4: [https://qa.mpi-inf.mpg.de/explaignn/explaignn_user_study.zip](https://qa.mpi-inf.mpg.de/explaignn/explaignn_user_study.zip)

\begin{table}
\begin{tabular}{l|c|c|}  & **User correct** & **User incorrect** & \\ \hline
**User certain** & 0.632 & 0.166 & 0.798 \\
**User uncertain** & 0.129 & 0.073 & 0.202 \\ \hline  & 0.761 & 0.239 & \\ \end{tabular}
\end{table}
Table 11. Confusion matrix for the user study, showing the probabilities of user correctness against user certainty.

\begin{table}
\begin{tabular}{l|l} \hline
**Answer correctness** (Correctness of the provided answer) & \(\mathcal{X}\) **Answer correctness (Correctness of the provided answer)** & \(\mathcal{X}\) **Predicted correctness (User assessment of the answer correctness)** & \(\mathcal{X}\) **Predicted correctness (User assessment of the answer correctness)** & \(\mathcal{X}\) **User correctness (Correctness of the user assessment)** & \(\mathcal{Y}\) **Predicted correctness (User assessment of the answer correctness)** & \(\mathcal{X}\) **
## 8. Related Work

**Conversational question answering**. There has been extensive research on ConvQA (Wang et al., 2018; Wang et al., 2019) in recent years, which can largely be divided into methods using a KB (Wang et al., 2018; Wang et al., 2019; Wang et al., 2019), methods using a text corpus (Wang et al., 2019; Wang et al., 2019; Wang et al., 2019), and methods integrating tables (Wang et al., 2019; Wang et al., 2019).

In **ConvQA over KBs**, the (potentially completed) question is often mapped to logical forms that are run over the KB to obtain the answer (Wang et al., 2018; Wang et al., 2019; Wang et al., 2019; Wang et al., 2019; Wang et al., 2019). A different type of approach is to search for the answer in the local neighborhoods of an ongoing context graph, which captures the relevant entities of the conversation (Wang et al., 2019; Wang et al., 2019; Wang et al., 2019). Early **ConvQA systems over textual sources** assumed the relevant information (i.e. text passage or document) to be given (Wang et al., 2019; Wang et al., 2019; Wang et al., 2019), and modeled the problem as a machine reading comprehension (MRC) task (Wang et al., 2019). This assumption was challenged in (Wang et al., 2019), which proposed ORConvQA introducing a retrieval stage. Recent works follow similar ideas, and mostly rely on _question rewriting_(Wang et al., 2019; Wang et al., 2019) or _question resolution_(Wang et al., 2019), and then employ a MRC model. In related work on **ConvQA over tables**, the answer is either derived via logical forms (Wang et al., 2019), or via pointer-networks operating on graph-encodings of the tables (Wang et al., 2019).

All of these methods rely on a single information source for answering questions, inherently limiting their answer coverage. Recently, there has been preliminary work on ConvQA using a mixture of the sources (Chen et al., 2021; Chen et al., 2021). The method proposed in (Chen et al., 2021) appends incoming questions to the conversational history, and then generates a program to derive the answer from a table using a sequence-to-sequence model. In (Chen et al., 2021), evidences from heterogeneous sources are concatenated and fed into a sequence-to-sequence model to generate the answer. Both methods heavily rely on sequence-to-sequence models where the generated outputs are not explainable, and may even be hallucinated.

**QA over heterogeneous sources**. In addition to work on ConvQA over heterogeneous sources, there is a long line of work on answering _one-off questions_ using such mixtures of sources (Chen et al., 2021; Chen et al., 2021; Wang et al., 2019; Wang et al., 2019; Wang et al., 2019; Wang et al., 2019; Wang et al., 2019). More recently, UniK-QA (Wang et al., 2019) proposed the verbalization of evidences, and then applied FiD (Chen et al., 2021) for the answering task. UDT-QA (Wang et al., 2019) improved over UniK-QA by implementing more sophisticated mechanisms for evidence verbalization, and use TS (Wang et al., 2019) to generate the answer. Similarly, Shen et al. (Shen et al., 2019) propose a dataset and method for answering questions on products from heterogeneous sources, leveraging BART (Wang et al., 2019). These approaches, being sequence-to-sequence models at their core, face similar problems as mentioned before. HeteroQA (Chen et al., 2021) explore heterogeneity in the context of community QA where retrieval sources could be posts, comments, or even other questions.

**Explainable QA**. Existing work is mostly on single-turn methods operating over a single source, with template (Chen et al., 2021; Chen et al., 2021) and graph-based derivation sequences (Wang et al., 2019; Wang et al., 2019) as mechanisms for ensuring explainability. Works on text-QA provide end users with actual passages and reasoning paths used for answering (Wang et al., 2019; Wang et al., 2019). Post-hoc explainability for QA over KBs and text is investigated in (Wang et al., 2019). These methods cannot be easily adapted to a conversational setting with incomplete follow-up questions.

**Explainability in GNNs**. Explainability for GNNs is an active field of research (Wang et al., 2019), devising general techniques to identify important features for the nodes in the graphs, or provide model-level explanations. Such approaches are mostly designed for developers, and therefore hardly applicable in our scenario. Through our iterative model, we propose a QA-specific method for deriving explanations of GNN predictions that can be understood by _average web users_.

## 9. Conclusion

There are three main takeaways for a broader audience from this work. First, at a time when large language models (LLMs) like Chat-GPT are used as a one-stop shop for most NLP tasks including ConvQA, our method Explaingnn stands out by providing traceable provenance of its answer predictions. Next, explainability for graph neural networks is an unsolved concern: we propose an iterative model that sequentially reduces the graph size as a medium for offering causal insights into the prediction process. Finally, for several systems in IR and NLP, performance, efficiency, and explainability are seen as trade-offs. Through our highly configurable solution, we show that in certain use cases, it is actually possible to find configurations that lie at the sweet spots of all the three factors. A natural future work would be to generalize these insights to other problems, like graph-based neural recommendation.
