Inductive Knowledge Graph Completion

81 concepts71 papers1 proposal

Knowledge graphs (KGs) serve as the structured backbone for modern information systems, mapping out relationships between entities like diseases and treatments, or users and products. However, traditional knowledge graph embedding models operate under a strict closed-world assumption. They are transductive: they assign a static, unique vector identifier to every entity during training.

If a new entity emerges after the model is finalized—such as a newly registered user, an emerging news topic, or a newly discovered biological variant—the system suffers from a vocabulary bottleneck. It cannot compute an embedding or perform inference for this out-of-vocabulary node without an expensive, full-network retraining cycle.

To resolve this limitation, researchers have shifted toward inductive knowledge graph completion. The goal is to build models that can immediately reason about entirely unseen entities by leveraging two primary sources of transferable information: graph topology and textual semantics.


Shifting from Identity to Topology

The core intuition behind structural inductive reasoning is simple: even if an entity's identity is completely new, the logical patterns of the relationships surrounding it are invariant. For example, if the system understands that X —[BornIn]→ Y —[LocatedIn]→ Z implies X —[CitizenOf]→ Z, it does not matter what specific entity X is. The logic resides entirely within the relations and the local graph structure.

Relational Message Passing

To exploit this invariance, models must decouple their reasoning from entity-specific embeddings. In Relational Message Passing for Knowledge Graph Completion, Wang et al. introduce PathCon, a framework that shifts the focus entirely to the relationships themselves. Instead of aggregating entity features, PathCon aggregates local context and connectivity paths using relational message passing. Because the model only learns parameters for a fixed vocabulary of relation types, it generalizes seamlessly to new entity sets.

Subgraph-Based Invariance

Another way to capture entity-independent logic is by isolating the local neighborhood where an inference needs to take place. As shown in Communicative Message Passing for Inductive Relation Reasoning, Mai et al. extract directed subgraphs enclosing the target entities. Their model, CoMPILE, uses a communicative message-passing scheme where nodes and edges update each other bidirectionally. This allows the network to capture asymmetric structural properties without relying on pre-learned global entity representations.

Taking this concept to its logical conclusion, Zhang et al. propose NORAN in Logical Reasoning with Relation Network for Inductive Knowledge Graph Completion. NORAN bypasses entity representations entirely by transforming the knowledge graph into a "Relation Network," where the triples themselves act as nodes. By learning how these relational triples interact globally, the model extracts pure logical patterns that remain robust even when applied to entirely new entity vocabularies.


Bridging Graph Space and Textual Semantics

While structural methods excel when an unseen entity is well-connected within a local subgraph, they struggle with the "cold-start" problem: what happens when a new entity arrives with few or no structural links? To bridge this gap, models leverage the textual descriptions or names of entities, mapping them into a shared semantic space.

[Unseen Entity Text Description] ──> [Text Encoder / PLM] ──> [Alignment Mapping] ──> [Graph Embedding Space]

Alignment Transformations

Early open-world extensions focused on aligning independent text and graph representations. In An Open-World Extension to Knowledge Graph Completion Models, Shah et al. demonstrate that a model can learn a linear transformation from a text-based embedding space (like Word2Vec) to a pre-trained graph embedding space. When a new entity appears, its text description is passed through this transformation to project a proxy vector directly into the graph space, allowing existing transductive models to perform zero-shot link prediction. Similarly, the JointE model by Zhao et al. in Zero-Shot Embedding for Unseen Entities in Knowledge Graph uses a pairwise interaction mechanism to map textual descriptions into a shared semantic space, outperforming traditional translation-based models.

Pre-trained Language Models as Dynamic Encoders

Modern architectures eliminate static graph embeddings altogether, replacing them with deep contextual representations from Pre-trained Language Models (PLMs). In SimKGC: Simple Contrastive Knowledge Graph Completion with Pre-trained Language Models, Wang et al. utilize a bi-encoder architecture to encode entity descriptions on the fly. By using contrastive learning with a sophisticated negative sampling strategy, SimKGC bypasses the need for fixed entity vocabularies entirely. The PLM acts as a zero-shot entity encoder, allowing the system to compute semantic similarity between any arbitrary text strings and effectively opening the closed-world graph.


Verbalizing Graph Neighborhoods

The latest evolution in inductive reasoning unifies structural topology and textual semantics through neighborhood verbalization. Instead of using separate graph neural networks and text encoders, these methods translate the local graph structure directly into natural language text prompts.

Graph Structure: (Entity A) —[BornIn]→ (City B)
      │
      ▼ Verbalization
Text Prompt: "Entity A was born in City B. What is the nationality of Entity A?"
      │
      ▼
[Generative Language Model (e.g., T5)] ──> Output: "Country C"

In Better Together: Enhancing Generative Knowledge Graph Completion with Language Models and Neighborhood Information, Chepurova et al. demonstrate that generative language models (like T5) become significantly better at predicting missing links for unseen entities when they are provided with a "verbalized" text description of a node's local neighborhood. By converting graph topology into text, the model leverages the pre-trained commonsense reasoning of the language model to evaluate the structural context.

This prompt-based paradigm also extends to complex multi-hop logical queries. In Query Structure Modeling for Inductive Logical Reasoning Over Knowledge Graphs, Wang et al. introduce SILR, a framework that uses structural prompts to describe a query's execution steps. By combining these prompts with specialized neural layers for logical operations, the model guides the language model through multi-hop reasoning paths over entirely new entities and relations, proving that text and structure, when unified, provide a robust solution to the open-world challenge.

Key Foundational Work

Zero-Shot Embedding for Unseen Entities in Knowledge Graph (2017) — contributed 1 concept elements to this direction.
Building memory with concept learning capabilities from large-scale knowledge base (2015) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_inductive_knowledge_graph_completion_b825384c,
  title = {inductive knowledge graph completion},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/inductive-knowledge-graph-completion/rdr_b825384cfd5b4782a76e868514cf38ba},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_inductive_knowledge_graph_completion_b825384c_v1,
  title = {inductive knowledge graph completion},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/inductive-knowledge-graph-completion/rdr_b825384cfd5b4782a76e868514cf38ba/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake