Scalable Multi-Hop Relational Reasoning for Knowledge-Aware Question Answering (2020)

Abstract: Existing work on augmenting question answering (QA) models with external knowledge (e.g., knowledge graphs) either struggle to model multi-hop relations efficiently, or lack transparency into the model’s prediction rationale. In this paper, we propose a novel knowledge-aware approach that equips pre-trained language models (PTLMs) has with a multi-hop relational reasoning module, named multi-hop graph relation network (MHGRN). It performs multi-hop, multi-relational reasoning over subgraphs extracted from external knowledge graphs. The proposed reasoning module unifies path-based reasoning methods and graph neural networks to achieve better interpretability and scalability. We also empirically show its effectiveness and scalability on CommonsenseQA and OpenbookQA datasets, and interpret its behaviors with case studies, with the code for experiments released.

## introduction many recently proposed question answering tasks require not only machine comprehension of the question and context, but also relational reasoning over entities (concepts) and their relationships by referencing external knowledge @xcite @xcite . for example, the question in fig. 1 requires a model to perform relational reasoning over mentioned entities, i.e., to infer latent relations among the concepts: {child, sit, desk, schoolroom}. background knowledge such as "a child is likely to appear in a schoolroom" may not be readily contained in the questions themselves, but are commonsensical to humans. despite the success of large-scale pre-trained language models (ptlms) (devlin et al., 2019; ò the first two authors contributed equally. the major work was done when both authors interned at usc. a sample question from commonsenseqa can be better answered if a relevant subgraph of conceptnet is provided as evidence. blue nodes correspond to entities mentioned in the question, and pink nodes correspond to those in the answer. the other nodes are associated entities introduced in subgraph extraction. ì indicates the correct answer. @xcite , these models fall short of providing interpretable predictions, as the knowledge in their pre-training corpus is not explicitly stated, but rather is implicitly learned. it is thus difficult to recover the evidence used in the reasoning process. this has led many to leverage knowledge graphs (kgs) @xcite @xcite . kgs represent relational knowledge between entities with multi-relational edges for models to acquire. incorporating kgs brings the potential of interpretable and trustworthy predictions, as the knowledge is now explicitly stated. for example, in fig. 1 , the relational path (child atlocation classroom synonym schoolroom) naturally provides evidence for the answer schoolroom. a straightforward approach to leveraging a knowledge graph is to directly model these relational paths. kagnet @xcite and mh-pgm @xcite extract multi-hop relational paths from kg and encode them with sequence models. application of attention mechanisms upon these relational paths can further offer good interpretability. however, these models are hardly scalable because the number of possible paths in a graph is (1) polynomial w.r.t. the number of nodes (2) exponential w.r.t. the path length (see fig. 2 ). therefore, some @xcite resort to only using one-hop paths, namely, triples, to balance scalability and reasoning capacities. graph neural networks (gnns), in contrast, enjoy better scalability via their message passing formulation, but usually lack transparency. the most commonly used gnn variant, graph convolutional networks (gcns) @xcite , perform message passing by aggregating neighborhood information for each node, but ignore the relation types. @xcite generalize gcns by performing relationspecific aggregation, making it applicable to multirelational graphs. however, these models do not distinguish the importance of different neighbors or relation types and thus cannot provide explicit relational paths for model behavior interpretation. in this paper, we propose a novel graph encoding architecture, multi-hop graph relation network (mhgrn), which combines the strengths of path-based models and gnns. our model inherits scalability from gnns by preserving the message passing formulation. it also enjoys interpretability of path-based models by incorporating structured relational attention mechanism. towards multi-hop relational reasoning, our key motivation is to allow each node to directly attend to its multi-hop neighbors by performing multi-hop message passing within a single layer. we outline the desired merits of knowledge-aware qa models in ## problem formulation and overview in this paper, we limit the scope to the task of multiple-choice question answering, although the formulation can be easily generalized to other knowledge-guided tasks (e.g., natural language inference). the overall paradigm of knowledgeaware qa is illustrated in fig. 3 . formally, given a question q and an external knowledge graph (kg) as the knowledge source, our goal is to identify the correct answer from a set c of given options. we turn this problem into measuring the plausibility score between q and each option a " c, after which we select the option with the highest plausibility score. to measure the score for q and a, we first concatenate q and a to form a statement @xmath0; a] and encode the statement s into the statement representation s. then we extract from the external kg a subgraph g (i.e., schema graph in kagnet (lin et al., 2019)), with the guidance of s (detailed in §5.1). this contextualized subgraph is defined as a multi-relational graph @xmath1, e, ). here v plausibility score graph extraction from kg graph encoder text encoder is a subset of entities in the external kg, containing only those relevant to s. e n v ✓ r ✓ v is the set of edges that connect nodes in v, where @xmath2, ⇧, m} are the ids of all pre-defined relation types. the mapping function as input, and outputs e q if i is an entity mentioned in q, e a if it is mentioned in a, and e o otherwise 2 . finally, we encode g into g, and concatenate s and g to calculate the plausibility score. ## background: multi-relational graph encoding methods we leave encoding of s to pre-trained language models and focus on the challenge of encoding graph g to capture latent relations between entities. current methods for encoding multi-relational graphs mainly fall into two categories: gnns and path-based models. gnns encode structured information by passing messages between nodes, directly operating on the graph structure, while pathbased methods first decompose the graph into paths and then pool their representations to form a graph representation. graph encoding with gnns. for a graph with n nodes, a graph neural network (gnn) takes a set of node features {h 1 , h 2 , . . . , h n } as input, and computes their corresponding node embeddings {h ¨1, h ¨2, . . . , h ¨n} via message passing @xcite . a compact graph representation for g can thus be obtained by pooling the node embeddings {h ¨i}: as a notable variant of gnns, graph convolutional networks (gcns) @xcite additionally update node embeddings by aggregating messages from its direct neighbors. rgcns (schlichtkrull et al., 2018) extend gcns to encode multi-relational graphs by defining relationspecific weight matrix w r for each edge type: graph encoding with path-based models. in addition to directly modeling the graph with gnns, a graph can also be viewed as a set of relational paths connecting pairs of entities. relation networks (rns) @xcite ) can be adapted to multi-relational graph encoding under qa settings. rns use mlps to encode all triples (one-hop paths) in g whose head entity is in @xmath3 here h j and h i are features for nodes j and i, e r is the embedding of relation r " r, h denotes vector concatenation. to further equip rn with the ability to model nondegenerate paths, @xcite adopts lstms to encode all paths connecting question entities and answer entities with lengths no more than k. it then aggregates all path embeddings via the attention mechanism: ## proposed method: multi-hop graph relation network (mhgrn) this section presents multi-hop graph relation network (mhgrn), a novel gnn architecture that unifies both gnns and path-based models. mhgrn inherits path-level reasoning and interpretabilty from path-based models, while preserving good scalability of gnns. ## experimental setup we introduce how we construct g ( §5.1), the datasets ( §5.2), as well as the baseline methods ( §5.3). appendix b shows more implementation and experimental details for reproducibility. ## results and discussions in this section, we present the results of our models in comparison with baselines as well as methods on the leaderboards for both commonsenseqa and openbookqa. we also provide analysis of models' components and characteristics. ## conclusion we present a principled, scalable method, mhgrn, that can leverage general knowledge via multi-hop reasoning over interpretable structures (e.g. con-ceptnet). the proposed mhgrn generalizes and combines the advantages of gnns and path-based reasoning models. it explicitly performs multi-hop relational reasoning and is empirically shown to outperform existing methods with superior scalablility and interpretability. we use 2-layer rgcn and single-layer mhgrn across our experiments. the numbers of parameter for each graph encoder are listed in