PaperlayerView exact revision on arXiv

Source-linked AI summary

Chains of Reasoning over Entities, Relations, and Text using Recurrent Neural Networks

Rajarshi Das, Arvind Neelakantan, David Belanger, Andrew McCallum

arXiv:1607.01426v3cs.CL

TL;DR

The paper addresses limited accuracy and practicality in neural multi-hop reasoning over entities and relations in large knowledge bases. It jointly models relations, entities, and entity-types, pools multiple paths with attention, and shares one RNN across relations. The approach reduces error across Freebase+ClueWeb and WordNet evaluations, while remaining limited by sparse long textual patterns.

  • Problem

    The paper seeks to extend neural networks with complex multi-step reasoning over entities and relations in large knowledge bases, beyond prior RNN path composition that lacked accuracy and practicality.

  • Method

    The model jointly represents relations, entities, and entity-types, uses neural attention to combine multiple paths, and shares a single RNN across target relation types.

  • Results

    The approach reduces error by 25% in Freebase+ClueWeb MAP, 54% for sparsely observed relations, and 84% in WordNet mean quantile versus prior systems.

  • Takeaways & Limitations

    Entity information, pooled path evidence, and shared parameters make RNN-based reasoning more accurate and practical across relation types and reasoning tasks.

  • Takeaways & Limitations

    The model cannot handle long textual patterns effectively because of sparsity.

Abstract

from arXiv · show

Our goal is to combine the rich multistep inference of symbolic logical reasoning with the generalization capabilities of neural networks. We are particularly interested in complex reasoning about entities and relations in text and large-scale knowledge bases (KBs). Neelakantan et al. (2015) use RNNs to compose the distributed semantics of multi-hop paths in KBs; however for multiple reasons, the approach lacks accuracy and practicality. This paper proposes three significant modeling advances: (1) we learn to jointly reason about relations, entities, and entity-types; (2) we use neural attention modeling to incorporate multiple paths; (3) we learn to share strength in a single RNN that represents logical composition across all relations. On a largescale Freebase+ClueWeb prediction task, we achieve 25% error reduction, and a 53% error reduction on sparse relations due to shared strength. On chains of reasoning in WordNet we reduce error in mean quantile by 84% versus previous state-of-the-art. The code and data are available at https://rajarshd.github.io/ChainsofReasoning

1 Introduction

The paper targets complex, multi-hop reasoning over large knowledge bases, extending neural approaches beyond single-evidence inference. It introduces entity-aware, multi-path, shared-parameter RNN modeling and reports substantial gains on Freebase+ClueWeb and WordNet tasks.

  • Motivation: Large knowledge bases require reasoning to infer facts that are not directly stored, beyond look-up-style question answering.The paper motivates reasoning as a way to address highly incomplete KBs.
  • Motivation: Multi-hop paths support richer inference by composing relations across three or more entities, such as inferring Melinda’s residence from a path through Bill and Microsoft.This extends reasoning beyond methods that operate on single pieces of evidence.
  • Contributions: The model jointly reasons about relation-types, entities, and entity-types, uses neural attention over multiple paths, and shares one RNN across target relations.These advances address errors from ignoring entities, discarded path evidence, and separate per-relation models.
  • Contributions: A shared high-capacity RNN improves practicality and accuracy by learning common composition parameters across relation types.The multitask architecture reduces the need for separate models while sharing strength during training.
  • Results: 25% error reduction in mean average precision is achieved on large-scale Freebase entities, relations, and ClueWeb text.The comparison is against the previous best on this dataset.
  • Results: 84% reduction in error in mean quantile is achieved on WordNet chains of reasoning versus previous state-of-the-art.The paper also reports a 54% error reduction for relations available only sparsely at training time.

2 Background

The background Path-RNN model represents an arbitrary-length path by sequentially composing its relation embeddings with an RNN. Its final hidden state is compared with a query-relation vector to score the inferred relation.

  • Path-RNN: Path-RNN takes a path between two entities and composes its relations with an RNN to infer a new relation between the endpoints.Reasoning is performed over conjunctions of relations in paths of arbitrary length.
  • Path representation: A path is formed by an entity pair connected through a sequence of relations and intermediate entities, with path length equal to the number of relations.The path set is obtained by random walks in the knowledge graph.
  • Path representation: The model sequentially combines relation vectors, producing an intermediate hidden representation at each path step.The relation representation has dimension d, while the hidden state has dimension h.
  • Scoring: Path-RNN uses separate parameters for each query relation, including relation-specific composition parameters.This specialized design motivates the later shared-parameter architecture.
  • Scoring: The path representation is the final hidden state h_k, which is compared with the query relation vector using a dot product.A higher similarity indicates stronger evidence for the query relation.

HQIn

The HQIn discussion highlights weaknesses of prior path-based reasoning: it can ignore entities, discard evidence from multiple paths, and require separate models for each relation type. The paper’s figures illustrate path evidence and the proposed entity- and relation-aware scoring setup.

  • Path evidence: Figure 1 represents entities as graph nodes and relations as labeled edges, including paths that combine relations from different documents.The Melinda–Seattle example illustrates a multi-hop path connecting entities indirectly.
  • Path evidence: Among multiple paths connecting an entity pair, some can predict the target relation while another path may be fictitious and uninformative.This motivates pooling evidence rather than relying on only one path.
  • Scoring: The path-query score is computed from the dot product between the final path representation and the query-relation vector.Higher scores indicate that the query relation is more likely to hold between the entity pair.
  • Shared modeling: Per-relation Path-RNN models are impractical for downstream applications because each relation type requires a separately trained and maintained model.Their parameters are also not shared across target relation types.
  • Path pooling: Selecting only the maximum-scoring path can ignore useful evidence and provides zero gradient updates to the other paths.The issue is especially problematic early in training, when the selected path may be random.
  • Entity information: Prior path models can assign identical scores to paths with the same relations even when their entities imply different predictions.The JFK–NYC–NY and Yankee Stadium–NYC–NY paths expose this limitation.

3 Modeling Approach

The modeling approach shares one RNN across target relations, pools evidence from multiple paths, and incorporates entity-type representations alongside relation and entity information.

  • 3.1 Shared Parameter Architecture: A single shared RNN represents composition across all target relations, reducing parameters and enabling multitask strength sharing.The shared architecture uses relation representations and composition matrices across target relations.
  • Training: The model trains on observed KB triples as positives and unobserved triples as negatives by minimizing negative log-likelihood.The shared parameters include embedding lookup tables and RNN parameters.
  • 3.2 Score Pooling: Multiple-path scores are combined using Top-(k), average, or LogSumExp pooling rather than relying only on a single path.Average and LogSumExp assign non-zero weights to all paths, while Top-(k) uses only the highest-scoring paths.
  • 3.2 Score Pooling: LogSumExp provides score-proportional gradient allocation across paths, functioning as a neural attention mechanism during backpropagation.Average gives every path an equal gradient share, whereas Top-(k) produces sparse gradients.
  • Entity and Entity-Type Modeling: Entity representations are formed by adding learned representations of up to seven frequently occurring entity types and projecting the result into the RNN.Entity types address the difficulty of learning representations for rarely occurring entities.

4 Related Work

The related work spans symbolic path extraction, random-walk reasoning, compositional neural models, and entity-type-aware relation extraction, while identifying limitations addressed by this paper.

  • Path-Based Reasoning: SHERLOCK exhaustively explores relational paths for symbolic clauses, whereas PRA uses random walks and per-target-relation binary classifiers.PRA was later extended with observed text patterns alongside schema relations.
  • Path-Based Reasoning: Some earlier approaches restrict reasoning to paths of length three or to schema types, limiting their coverage of relational structure.These restrictions are described for prior extensions of path-based reasoning methods.
  • Compositional Neural Models: Earlier compositional models differ in path coverage and entity modeling: Guu et al. model one path, while Toutanova et al. model intermediate entities and multiple paths.The latter approach requires storing scores for intermediate path lengths across entity pairs.
  • Entity Types and Neural Models: Prior relation-extraction and entailment methods incorporate entity types for candidate entities, sentence-level extraction, KB extraction, and learning entailment rules.Other work uses RNNs to generate factoid questions from Freebase.

5 Results

Experiments evaluate pooling, parameter sharing, entity and type modeling, limited-data training, and path-query reasoning across Freebase+ClueWeb and WordNet. LogSumExp, shared models, and entity-aware representations improve performance, while the WordNet evaluation shows an 84% error reduction versus prior state of the art.

  • Effect of Pooling Techniques: LogSumExp achieves the best pooling results and decreases training loss fastest, indicating faster training than alternative pooling methods.Its non-zero gradient updates for all paths contrast with max pooling’s sparse gradients, especially early in training.
  • Effect of Pooling Techniques: 73.2 vs 72.4 in MAP, comparing the reported LogSumExp and LSTM results.
  • Comparison with Multi-Hop Models: The Single-Model outperforms Path-RNN and PRA, while LogSumExp also strengthens the Path-RNN baseline.The Single-Model shares parameters across target relations, and the Path-RNN with LogSumExp and Single-Model scores are significant with p < 0.005.
  • Effect of Incorporating Entities: Entity representations based on annotated Freebase types produce the best performance, whereas separate entity representations perform slightly worse.The type-based representation helps with unseen test-time entities because the number of entity types is relatively limited.
  • Performance in Limited Data Regime: The limited-data experiment randomly selects 23 of 46 relations and retains only 1% of the positive and negative training triples.Single-Model provides a clear performance jump in this setting, while additional multitask training with types gives only an incremental gain.
  • Answering Path Queries: 84% reduction in error on WordNet mean quantile compared with Guu et al. (2015), although the dataset has few unseen paths and usually one path per entity pair.Mean Quantile is the fraction of incorrect entities scored lower than the correct entity.

6 Qualitative Analysis

The qualitative analysis shows that entity information helps the model distinguish otherwise ambiguous paths, while top-scoring paths commonly contain three to five relations. It also identifies sparsity in long textual patterns as a major limitation.

  • Entities as Existential Quantifiers: Entity-aware scoring separates paths whose relation sequences are identical but whose entity instantiations imply different predictions.The model without entity information assigns the same score to both paths, whereas the proposed model conditions on the entities.
  • Entities as Existential Quantifiers: Both models score an entity-independent clause highly, but only the entity-aware model confidently identifies the true relation for an ambiguous clause.The entity-free model cannot discriminate because the path occurs in both positive and negative training examples.
  • Length of Clauses: Top-scoring test paths peak at lengths 3, 4, and 5, suggesting that restricting paths to length 3 may limit performance and generalizability.The distribution is shown in Figure 4.
  • Limitation: A major limitation is the model’s inability to handle long textual patterns because of sparsity.Compositional approaches for modeling text are identified as a direction for future work.

7 Conclusion

The conclusion presents a single high-capacity RNN for reasoning across multiple relation types, using intermediate entities and annotated types while pooling evidence from multiple paths. These design choices improve handling of unseen entities and the speed and accuracy of training.

  • 7 Conclusion: A single high-capacity RNN supports chains of reasoning across multiple relation types.The model uses one shared recurrent architecture for the reasoning task.
  • 7 Conclusion: The model uses intermediate entities and annotated entity types, mitigating problems caused by unseen entities.Unseen entities are represented as a function of their annotated types.
  • 7 Conclusion: Pooling evidence across multiple paths improves training speed and accuracy.The conclusion identifies this as a demonstrated benefit of the approach.
Loading 1607.01426v3…