1 Introduction↩︎

A knowledge graph (KG) is a heterogeneous graph in which nodes represent entities and edges represent relations that connect them. Knowledge is typically encoded as triples of the form (head, relation, tail). Knowledge graphs provide structured frameworks for representing real-world facts, enabling knowledge inference and logical reasoning. Consequently, they have been widely adopted across many domains to extract and organize structured knowledge from unstructured or semi-structured data.

Building on this structured representation, numerous tasks have been formulated for knowledge graphs. Tasks that operate directly on the graph structure, such as link prediction [1] and triple classification [2], aim to infer missing facts or validate existing ones within the graph. In contrast, beyond-KG tasks leverage knowledge graphs as auxiliary sources of structured knowledge to enhance downstream applications, including question answering [3], recommender systems [4]–[6], and semantic web technologies [7].

Real-world knowledge is inherently incomplete and continually evolving; as a primary structured representation of such knowledge, knowledge graphs are therefore naturally incomplete as well. Addressing this incompleteness is crucial, as completing missing information enriches knowledge, bridges scientific gaps, and enables more advanced reasoning.

Knowledge graph completion, which is most commonly formulated as link prediction, seeks to infer missing facts by learning structural regularities from the observed portion of the graph while preserving real-world semantics. Early transductive embedding models, such as TransE [1], ComplEx [8], and RotatE [9], embed entities and relations into continuous vector spaces. Despite their effectiveness, these models operate in a transductive setting, meaning they can only make predictions for entities seen during training.

As knowledge graphs grow rapidly, new entities emerge frequently, rendering purely transductive models ineffective in real-world scenarios. As highlighted by Weninger et al. [10], the dynamic nature of knowledge demands models capable of generating plausible embeddings for previously unseen entities, that is, inductive models.

Several inductive approaches have been proposed [11], [12]; however, most of them rely solely on the local neighborhood of each entity and initialize embeddings for unseen entities randomly, limiting both the quality and generalizability of the learned representations. To overcome these limitations, we propose Model Graph Inductive Learning (MGIL), a novel framework that generates entity embeddings by integrating both global structural patterns of the knowledge graph and the local context of individual entities.

Beyond providing a global view of the knowledge graph, the Model Graph also serves as a principled initialization mechanism for entity representations. By assigning entities to structurally coherent clusters, MGIL provides informative initial embeddings that guide the subsequent GNN-based message passing process. This structured initialization facilitates more stable optimization and allows the GNN to learn more meaningful and expressive embeddings for individual entities.

MGIL consists of two tightly coupled components:

1. A global module that operates on the model graph to generate structural representations, which serve as meaningful initializations for entity embeddings in subsequent modules (as described in Section 3.4.1).

2. A local module that refines these representations using entity-centered induced subgraphs and a graph neural network (see Section 3.4.2).

The final entity embedding is obtained by combining the global prototype (from the model graph) with the locally refined representation. This design yields expressive and generalizable embeddings for both seen and unseen entities in fully inductive settings.

The constructed model graph offers several desirable properties:

• Graph Coarsening: The model graph contains fewer nodes than the original KG by grouping entities with similar relational patterns or semantic types into abstract nodes, yielding a more compact representation. In some cases, the reduction is substantial.

• Similarity Mapping: Unseen entities are mapped to the most similar model graph nodes, immediately receiving meaningful embeddings.

• ID-independence: Since embeddings are derived from structural similarity to nodes of model graph rather than entity identifiers, the model generalizes naturally to unseen entities.

Extensive experiments on standard inductive knowledge graph benchmarks show that MGIL consistently achieves state-of-the-art or highly competitive, demonstrating its effectiveness in generalizing to unseen entities.

In summary, our main contributions are as follows:

1. The introduction of the Model Graph, a high-level structural abstraction derived from surrounding relational patterns or entity types.

2. The extraction of entity-centered induced subgraphs that enable learning on small local graph structures instead of the entire knowledge graph, leading to more efficient and generalizable modeling.

3. A dual-module framework that jointly learns global structural representations and local refinements, enabling expressive and generalizable inductive knowledge graph completion without relying on entity identifiers.

The source code and datasets used in this paper have been made available at https://github.com/hhaji/MGIL.

2 Related work↩︎

Knowledge graph completion and link prediction have attracted significant research attention, leading to a diverse range of proposed methods. These approaches can broadly be categorized into four groups: path-based, embedding-based, rule-based, and GNN-based methods.

2.1 Path-based methods↩︎

Path-based methods exploit graph connectivity patterns to measure similarity between nodes or to infer new links. Originally developed for homogeneous graphs, such methods compute similarity based on various path-related metrics, including the weighted count of paths (Katz index [13]), random-walk probabilities (personalized PageRank [14]), or shortest-path distances [15]. SimRank [16] introduces a measure of similarity based on the expected meeting distance of random walks, which was later extended to heterogeneous graphs by PathSim [17]. In the context of knowledge graphs, the Path Ranking Algorithm (PRA) [18] leverages relational paths as symbolic features for link prediction, enabling reasoning based on explicit multi-hop relations. Despite their effectiveness, path-based methods suffer from several limitations. They typically rely on handcrafted features and manually defined paths, which require domain expertise and extensive feature engineering [17]–[19]. Moreover, many of these approaches were originally designed for homogeneous graphs and may require careful design to generalize to complex heterogeneous knowledge graphs.

2.2 Embedding-based models↩︎

Embedding-based methods aim to represent entities and relations of a knowledge graph as low-dimensional vectors by training on observed triples, mapping them into a continuous vector space where the plausibility of a triple \((h, r, t)\) can be measured via a scoring function. Classical models such as TransE [1], TransH [2], ComplEx [8], and RotatE [9] fall into this category. These approaches are considered shallow embeddings, as they directly assign and optimize embeddings for each entity and relation without capturing neighborhood structure or inter-triple dependencies. Most of these models operate in a transductive setting, meaning they cannot naturally generalize to unseen entities. Moreover, incorporating new entities or relations often requires full retraining, as the model has no mechanism to infer embeddings for previously unseen elements.

2.3 Rule-based methods↩︎

Unlike embedding-based approaches, rule-based methods rely on learning statistical and logical rules by enumerating regularities and patterns present in the knowledge graph. These rules can then be applied for inductive reasoning, enabling generalization to unseen entities. Classical methods such as AMIE [20] and RuleN [21] explicitly search for logical rules through discrete exploration, while more recent neural approaches such as Neural LP [22] and DRUM [23] learn rules in an end-to-end differentiable manner. Since the learned rules are independent of specific entities, rule-based models are particularly effective in handling link prediction tasks involving unseen entities.

However, learning a large set of logical rules often introduces scalability challenges, as rule enumeration and evaluation can become computationally expensive on large-scale knowledge graphs. Moreover, the expressiveness of rule-based methods is inherently constrained by predefined rule templates, limiting their ability to capture complex and diverse relational patterns.

2.4 GNN-based methods↩︎

GNN-based methods leverage the topological structure of knowledge graphs to encode entities and relations into expressive embeddings. Early works such as R-GCN [24] and CompGCN [25] extend standard GNNs, originally designed for simple undirected graphs, to multi-relational knowledge graphs by incorporating relation-specific transformations and relation embeddings. Subgraph-based methods, such as GraIL [11], further advance this idea by extracting local subgraphs around target triples and scoring them using a GNN, enabling inductive reasoning over unseen entities. Several follow-up works have built on this framework, including [12], [26], [27], demonstrating improved performance in link prediction and reasoning tasks.

Despite their strong expressive power, GNN-based methods typically suffer from high computational complexity, particularly when applied to large-scale knowledge graphs with many relations. Moreover, most existing GNN-based approaches generate entity embeddings primarily by exploiting local neighborhood structures. While local subgraphs capture important relational signals, they may overlook global structural characteristics of the knowledge graph, which can provide complementary and high-level relational context.

Another limitation of many GNN-based models is that entity embeddings are commonly initialized using random vectors before message passing. Such random initialization provides no structural prior and may lead to unstable optimization or suboptimal representation learning, especially in inductive settings where entities are unseen during training.

In contrast, our proposed Model Graph Inductive Learning (MGIL) framework explicitly integrates both global and local structural information. MGIL constructs a global model graph to capture high-level relational patterns across the entire knowledge graph and uses this abstraction to provide a structured and semantically informed initialization for entity representations. These informed initial representations serve as a principled starting point for subsequent GNN-based message passing, facilitating more stable training and more expressive embeddings. MGIL then combines this global structural signal with local entity-centered subgraphs to generate more robust representations for entities and relations.

3 Proposed Methodology↩︎

3.1 Motivation and Main Idea↩︎

A fundamental challenge in knowledge graph modeling lies in the limited ability of conventional methods to generalize to unseen entities at inference time. Most classical representation learning approaches for knowledge graphs [1]–[3], [8], [9] operate in a transductive setting, assuming a fixed set of entities and relations observed during training. Consequently, when new entities emerge at test time, these models cannot naturally produce meaningful latent representations for them, which significantly limits their applicability in dynamic and evolving knowledge graphs.

A key motivation for our approach is that entities may share high-level structural or semantic similarities even when they are distant or disconnected within the knowledge graph. In many cases, two entities can participate in analogous relational patterns and exhibit comparable neighborhood configurations despite having no direct or indirect paths between them. As illustrated in Figure 1, entities \(e_8\) and \(e_9\) are located in distant regions of the original knowledge graph, yet they demonstrate highly similar relational interaction patterns.

Moreover, beyond relational pattern similarity, entities may also share intrinsic semantic properties, such as belonging to the same entity type (e.g., drug, protein, or side-effect in biomedical knowledge graphs). Such global structural or semantic commonalities are not necessarily reflected in local connectivity patterns. For example, as illustrated in Figure 2, entities such as Aspirin and Metformin may not be directly connected in the knowledge graph, yet both belong to the semantic category of drugs. In the corresponding model graph, these entities can therefore be represented by a single shared abstract node representing the drug type.

These observations reveal an important limitation of existing subgraph-based and GNN-based approaches [11], [24], [25], which primarily rely on local message passing over observed graph neighborhoods and therefore may struggle to capture global relational roles or coarse-grained semantic abstractions.

To address this limitation, we construct a model graph that abstracts entities into higher-level nodes according to shared structural characteristics. Specifically, entities can be grouped either based on high relational similarity or based on intrinsic semantic types. We refer to these two constructions as the relation-based model graph and the entity-based model graph, respectively. The relational construction clusters entities that share analogous incoming and outgoing relation patterns, whereas the type-based construction aggregates entities belonging to the same semantic category into a shared abstract node. For example, in a biomedical knowledge graph, all drug entities may be represented by a single abstract node, while all protein entities form another abstract node.

Consider the knowledge graph in Figure 1. On the left side, the knowledge graph contains entities such as \(e_1\), \(e_2\), \(e_3\), \(e_4\), \(e_5\), \(e_6\), \(e_7\), \(e_8\), and \(e_9\). Each entity is associated with a set of incoming and outgoing relations, illustrated by arrows of different colors, where each color denotes a distinct relation type.

Entities such as \(e_4\), \(e_8\), and \(e_9\) exhibit highly similar relational structures: they share comparable incoming relations (e.g., blue arrows) as well as outgoing relations (e.g., red and orange arrows), together with analogous neighborhood configurations. Although these entities may be located in distant regions of the graph, their relational signatures are structurally similar. Based on this observation, we construct a relation-based model graph in which entities with highly similar relational patterns are grouped into the same abstract node. Accordingly, \(e_4\), \(e_8\), and \(e_9\) are mapped into a single cluster (the green node) in the model graph.While this construction relies on relational similarity, an alternative abstraction can be defined based on semantic properties. Figure 2 illustrates the construction of an alternative entity-based knowledge graph. Instead of clustering entities based on their relational patterns, entities are grouped according to their intrinsic semantic types. For instance, drugs such as Aspirin, Metformin, and Ibuprofen are represented as a single abstract node, and similarly, all entities of the same type are aggregated into type-specific nodes. This type-based abstraction provides a coarse-grained yet semantically meaningful summarization of the original graph, preserving the overall structure while simplifying visualization and analysis.

This distinction becomes particularly important in large-scale and heterogeneous knowledge graphs such as HetioNet. In such datasets, the graph is often incomplete, and the local neighborhood of many entities may be only partially observed, with several relevant relations missing. Consequently, constructing a model graph purely based on relational patterns may lead to unreliable or fragmented clusters, and in some cases, the number of nodes in the model graph may approach that of the original graph (see Table 1).

In these scenarios, an entity-centric abstraction based on intrinsic semantic properties provides a more stable and compact alternative. By grouping entities according to their inherent characteristics rather than relying solely on observed connectivity, the model graph becomes significantly smaller and less sensitive to missing relational information. This leads to a more robust structural representation and can improve generalization performance, particularly in inductive settings where relational evidence is sparse or incomplete.

The resulting model graph is typically smaller than the original knowledge graph, and in some cases substantially smaller, particularly when strong structural or semantic regularities exist among entities. However, this reduction is not guaranteed and depends on the characteristics of the dataset. This compression enables efficient and scalable GNN-based message passing over a more compact abstraction while preserving a global view of relational or semantic patterns.

However, as shown in Table 1, the degree of compression varies across datasets. In cases where relational patterns are highly diverse or incomplete—such as large-scale heterogeneous graphs (e.g., CoDEx-M or HetioNet)—the reduction in the number of nodes may be less pronounced.

This observation further motivates the use of entity-centric abstractions in certain scenarios. In datasets like HetioNet, where relational neighborhoods may be partially observed or noisy, clustering entities purely based on relational patterns can lead to fragmented representations and relatively large model graphs. In contrast, leveraging intrinsic semantic properties of entities allows for more compact and stable abstractions, significantly reducing the number of model graph nodes and improving representation quality.

3.2 Model Graph Construction↩︎

The knowledge graph (KG) is formally defined as \(\mathcal{G} = (\mathcal{V}, \mathcal{R}, \mathcal{E})\), where \(\mathcal{V}\) denotes the set of entities, \(\mathcal{R}\) is the set of relations, and \(\mathcal{E} \subseteq \mathcal{V} \times \mathcal{R} \times \mathcal{V}\) represents the set of edge (i.e relational triples).

The construction of a model graph from a knowledge graph involves two main scenarios: relation-based model graphs and entity-based model graphs. In a relation-based model graph, entities are grouped according to the similarity of their relational patterns; each node represents a cluster of entities that share similar incoming and outgoing relation types. In an entity-based model graph, nodes are constructed based on the intrinsic types or features of the entities themselves.

3.2.1 Relation-Based Model Graph↩︎

We construct the relation-based model graph based on the given knowledge graph \(\mathcal{G} = (\mathcal{V}, \mathcal{R}, \mathcal{E})\), where \(\mathcal{R} = \{r_1, \ldots, r_{|\mathcal{R}|}\}\).

For each entity \(v_i \in \mathcal{V}\), we define a relational feature vector \(\vec{f}_i \in \{0,1\}^{2|\mathcal{R}|}\) that encodes both outgoing and incoming relations associated with the entity. The first \(|\mathcal{R}|\) dimensions correspond to outgoing relations, while the remaining \(|\mathcal{R}|\) dimensions correspond to incoming relations. Formally, for each index \(j \in \{1, \ldots, 2|\mathcal{R}|\}\): \[\vec{f}_i[j] = \begin{cases} 1 & \text{if } j \leq |\mathcal{R}| \text{ and } \exists (v_i, r_j, v_k) \in \mathcal{E}, \\ 1 & \text{if } j > |\mathcal{R}| \text{ and } \exists (v_k, r_{j-|\mathcal{R}|}, v_i) \in \mathcal{E}, \\ 0 & \text{otherwise}. \end{cases}\]

The duplication of relation dimensions allows us to explicitly distinguish between outgoing and incoming relational roles, which is essential since an entity may participate in both directions of a relation (e.g., parent vs. child).

Figure 3 illustrates an example of the relational feature vector construction for the entity \(e_5\).

After defining the feature vector \(\vec{f}_i\) for each entity \(v_i \in \mathcal{V}\), our goal is to group entities that share identical relational feature vectors.

We construct a model graph \(M_G = (V_m, E_m)\), where each node corresponds to a unique relational feature pattern.

First, we extract the set of unique feature vectors: \[F = \left\{ \vec{f}_i \in \{0,1\}^{2|\mathcal{R}|} \;\middle|\; v_i \in \mathcal{V} \right\}.\]

Each unique feature vector \(\vec{f}_j \in F\) defines a node \(U_j \in V_m\) in the model graph: \[V_m = \{ U_j \mid \vec{f}_j \in F \}.\]

Each node \(U_j\) represents the set of entities sharing the same feature vector: \[U_j = \{ v_i \in \mathcal{V} \mid \vec{f}_i = \vec{f}_j \}.\]

An undirected edge \((U_j, U_k) \in E_m\) is established if there exists at least one triple \((v_p, r, v_q) \in \mathcal{E}\) such that \(v_p \in U_j\) and \(v_q \in U_k\): \[(U_j, U_k) \in E_m \iff \exists (v_p, r, v_q) \in \mathcal{E} \text{ with } v_p \in U_j \text{ and } v_q \in U_k.\] Formally, the proposed model graph \(M_G\) can be viewed as a quotient graph of the original knowledge graph \(\mathcal{G}\) under an equivalence relation defined over entities, where \(v_i \sim v_j\) if and only if \(\vec{f}_i = \vec{f}_j\). Under this formulation, each node in \(M_G\) corresponds to an equivalence class of entities, and edges capture inter-class connectivity induced by the original graph.

The overall construction procedure is summarized in Algorithm 4, which describes how relational feature vectors are computed, entities are grouped, and edges are formed based on observed interactions in the knowledge graph.

This construction yields a compact representation of the original knowledge graph, where entities with identical relational roles are aggregated into representative nodes. Such abstraction significantly reduces the graph size while preserving essential structural information, thereby enabling efficient and scalable inductive reasoning.

Table 1 reports the statistics of the constructed model graphs across several benchmark datasets, demonstrating that the proposed construction yields a smaller graph than the original knowledge graph.

3.2.2 Entity-Based Model Graph↩︎

To formalize the construction of an entity-based model graph, we begin with a given knowledge graph \[\mathcal{G} = (\mathcal{V}, \mathcal{R}, \mathcal{E}, \tau),\] where \(\tau(v)\) denotes the type of entity \(v \in \mathcal{V}\). Let the set of all entity types be denoted as \(\{t_1, t_2, \ldots, t_k\}\). The entity-based model graph is defined as \(M_G = (V_m, E_m)\), where each node \(U_j \in V_m\) corresponds to an entity type \(t_j\), for \(1 \leq j \leq k\). Specifically, each node \(U_j\) represents the subset of entities sharing the same type: \[U_j = \{ v_i \in \mathcal{V} \mid \tau(v_i) = t_j \}, \quad 1 \leq j \leq k.\]

We define an undirected edge \((U_j, U_k) \in E_m\) if there exists at least one triple \((h, r, t) \in \mathcal{E}\) such that \(\tau(h) = t_j\) and \(\tau(t) = t_k\), or vice versa.

This construction can also be interpreted as a quotient graph, where the equivalence relation is defined based on entity types, i.e., two entities are equivalent if they share the same type.

3.3 Subgraph Generation Procedure↩︎

In this work, we construct a collection of \(K\) task-specific subgraphs for meta-learning. The subgraph generation procedure follows the framework introduced by [29], with adaptations to ensure consistency with our formulation and to support inductive generalization. Given a knowledge graph \(\mathcal{G} = (\mathcal{V}, \mathcal{R}, \mathcal{E})\), each subgraph is constructed independently through a three-stage sampling process.

First, for each subgraph \(i \in \{1, \dots, K\}\), an initial entity is randomly sampled from \(\mathcal{V}\). Starting from this entity, a uniform random walk of length \(l_{rw}\) is performed \(n_{rw}\) times to collect a set of entities, denoted as \(\mathcal{V}_{rw}^{(i)}\). This procedure is repeated \(t_{rw}\) times with different starting entities, and the resulting sets are merged to improve coverage and structural diversity.

Second, an induced subgraph \(T_i \subseteq \mathcal{E}\) is constructed by including all triples \((h, r, t) \in \mathcal{E}\) such that \(h, t \in \mathcal{V}_{rw}^{(i)}\): \[T_i = \left\{ (h, r, t) \in \mathcal{E} \;\middle|\; h, t \in \mathcal{V}_{rw}^{(i)} \right\}.\]

Third, to prevent information leakage and avoid overfitting to entity identities, the entities in each subgraph are anonymized by re-indexing them using a random permutation over \(\{1, \dots, |\mathcal{V}_{rw}^{(i)}|\}\).

Finally, the triples in each subgraph \(T_i\) are randomly partitioned into two disjoint subsets: a support set \(S_i\) and a query set \(Q_i\), such that \(S_i \cup Q_i = T_i\) and \(S_i \cap Q_i = \emptyset\). The support set is used for model adaptation, while the query set is used for evaluation.

The resulting \(K\) subgraphs are split into meta-training and meta-validation sets using a predefined ratio \(\alpha \in (0,1)\), where \(\lfloor \alpha K \rfloor\) subgraphs are used for meta-training and the remainder for validation. For final evaluation, we use the fixed official test triples provided by each benchmark dataset without subgraph sampling. To avoid information leakage, test triples are strictly excluded from the subgraph generation and meta-training process, ensuring that no structural or relational information from the test set is observed during training.

This subgraph-based construction exposes the model to diverse structural patterns, improving inductive generalization while reducing computational cost compared to training on the full graph.

3.4 Learning Embeddings↩︎

After constructing the model graph and sampling induced subgraphs, the proposed framework learns entity embeddings through three tightly coupled components. First, global structural representations are learned on the model graph. Second, these global embeddings are injected into the knowledge graph and refined using local relational information via an R-GCN. Finally, the resulting embeddings are evaluated through a scoring function for knowledge graph completion. We describe each component in detail below.

3.4.1 Embedding Learning on the Model Graph↩︎

To obtain latent representations for the model graph, each node is initialized with a random embedding vector sampled from a standard normal distribution. These embeddings are subsequently refined through multiple layers of a standard Graph Convolutional Network (GCN), which performs message passing and aggregation to capture higher-order structural dependencies encoded in the model graph.

Given the model graph \(M_G = (V_m, E_m)\), each node \(U \in V_m\) is assigned an initial embedding \(\mathbf{h}_U^{(0)} \in \mathbb{R}^d\). The embeddings are updated layer by layer as follows:

\[\mathbf{h}_U^{(l+1)} = \boldsymbol{ReLU} \left( \sum_{U' \in \mathcal{N}(U) \cup \{U\}} \frac{1}{\sqrt{\tilde{d}_{U'} \tilde{d}_U}} \cdot \mathbf{W}^{(l)} \mathbf{h}_{U'}^{(l)} \right), \quad U \in V_m,\] where \(\tilde{d}_U = |\mathcal{N}(U)| + 1\) denotes the degree of node \(U\) after adding self-loops, and \(\mathbf{W}^{(l)}\) is a trainable weight matrix.

After \(L\) propagation layers, the embeddings \(\mathbf{h}_U^{(L)}\) serve as the final latent representations of nodes in the model graph, capturing structural interactions among equivalence classes and encoding high-level structural patterns.

3.4.2 Injecting Model Graph Embeddings into the Knowledge Graph and Reasoning with R-GCN↩︎

After obtaining the latent embeddings \(\mathbf{h}_U^{(L)}\) for nodes in the model graph, these embeddings are used to initialize the corresponding entity representations in the knowledge graph. Since each node in the model graph may represent multiple entities, the embedding of a model node is assigned to all entities mapped to it:

\[\mathbf{z}_v^{(0)} = \mathbf{h}_{\psi(v)}^{(L)}, \quad \forall v \in \mathcal{V}.\] where \(\psi : \mathcal{V} \rightarrow V_m\) is a deterministic mapping that assigns each entity to a model graph node according to the feature signature used to construct the model graph. Specifically, for the relation-based model graph, \(\psi(v)\) is determined by the relational feature vector of \(v\) as described in Section 3.2.1; for the entity-based model graph, \(\psi(v)\) is determined by the entity type or intrinsic feature of \(v\) as described in Section 3.2.2.

Each node \(U \in V_m\) represents a group of entities sharing the same feature signature, and the same initial embedding is assigned to all entities in the corresponding group.

To refine these initial embeddings, we employ a Relational Graph Convolutional Network (R-GCN). At layer \(l+1\), the embedding of entity \(v\) is updated as:

\[\mathbf{z}_v^{(l+1)} = \boldsymbol{ReLU} \left( \sum_{r \in \mathcal{R}} \sum_{v' \in \mathcal{N}_r(v)} \frac{1}{|\mathcal{N}_r(v)|} \mathbf{W}_r^{(l)} \mathbf{z}_{v'}^{(l)} + \mathbf{W}_0^{(l)} \mathbf{z}_v^{(l)} \right)\] where \(\mathcal{N}_r(v)\) denotes the set of neighbors of \(v\) under relation \(r\), \(\mathbf{W}_r^{(l)}\) and \(\mathbf{W}_0^{(l)}\) are trainable relation-specific and self-loop weight matrices, respectively.

Relational reasoning is performed via message passing over sampled subgraphs of the knowledge graph. For each subgraph, the initial features are injected from the model graph, and refined through multiple R-GCN layers. The final embeddings \(\mathbf{z}_v^{(L)}\) encode latent semantic representations of entities by combining high-level structural information from the model graph with local relational dependencies captured by the R-GCN.

3.4.3 Scoring Knowledge Graph Triples↩︎

Once the latent embeddings of entities are obtained, each query triple \((h, r, t)\) is assigned a score using a knowledge graph scoring function. In this work, we adopt TransE as the scoring function, defined as:

\[s(h, r, t) = -\| \mathbf{z}_h + \mathbf{r}_r - \mathbf{z}_t \|_2\] where \(\mathbf{z}_h, \mathbf{z}_t \in \mathbb{R}^d\) denote the learned embeddings of the head and tail entities, and \(\mathbf{r}_r \in \mathbb{R}^d\) is the trainable embedding associated with relation \(r\). The matrix \(\mathbf{R} \in \mathbb{R}^{|\mathcal{R}| \times d}\) contains all relation embeddings.

In the meta-training phase, we optimize the model parameters \(\theta\) and \(\phi\), where \(\theta\) corresponds to the model graph encoder and \(\phi\) corresponds to the R-GCN-based refinement module. We define a unified embedding function \(f_{\text{MG-RGCN}}(\cdot)\), which maps an input subgraph \(T_i\) to entity representations by first injecting model graph embeddings and then refining them via relational message passing.

The training objective is defined as:

\[\mathcal{L}_i = \mathcal{L}(Q_i \mid f_{\text{MG-RGCN}}(T_i), \mathbf{R})\]

We optimize the model using a self-adversarial negative sampling loss [9]. For each task \(i\) and its query triples \(Q_i\), the objective function is defined as:

\[\begin{align} \mathcal{L}_i = & \sum_{(h,r,t) \in Q_i} -\log \sigma(\gamma + s(h,r,t)) \\ & - \sum_{(h',r,t') \in \mathcal{N}_i} p(h',r,t') \log \sigma(-\gamma - s(h',r,t')) \end{align}\] where \(\sigma(\cdot)\) denotes the sigmoid function, \(\gamma\) is a fixed margin hyperparameter, and \(\mathcal{N}_i\) represents the set of negative samples generated by corrupting either the head or tail entity of each triple.

The self-adversarial weights are computed as:

\[p(h', r, t') = \frac{\exp(\beta \cdot s(h', r, t'))}{\sum_{(h'',r,t'') \in \mathcal{N}_i} \exp(\beta \cdot s(h'', r, t''))}\] where \(\beta\) is a temperature hyperparameter that controls the sharpness of the distribution and emphasizes harder negative samples by assigning them higher importance during training.

After meta-training, the function \(f_{\text{MG-RGCN}}\) can generate structure-aware entity embeddings for unseen subgraphs, enabling inductive generalization to new entities and graph structures.

The overall pipeline of the proposed framework is illustrated in Figure 5, where the input knowledge graph is first transformed into a model graph, then encoded using a multi-layer GNN, and finally injected into the knowledge graph for R-GCN-based reasoning.

4 Experimental Setup↩︎

In this section, we evaluate the effectiveness of MGIL on inductive link prediction. Models are trained on a source knowledge graph and evaluated on an entity-disjoint target graph containing entities unseen during training.

We evaluate MGIL on two categories of benchmark datasets. The first follows the inductive splits introduced by [11] and [26]. The second consists of datasets proposed by [28], which minimize structural overlap between source and target graphs to provide a stricter test of inductive generalization.

During training, we construct task-specific subgraphs from the source KG using random-walk-based sampling (detailed in Section 3.3). Each task consists of a sampled subgraph used to learn transferable structural representations.

For each dataset, MGIL is trained on the source KG and evaluated on the target KG by predicting missing triples. No additional subgraph sampling is performed during evaluation; performance is measured directly on the full target graph. This evaluation protocol enables a systematic examination of the model’s capacity to generalize structural and relational information to unseen entities.

4.1 Constructing the Model Graph↩︎

We construct two types of model graphs depending on the availability of entity type information in the knowledge graph:

4.1.0.1 Relation-Based Model Graph.

This construction requires no additional entity type information and can be applied to any knowledge graph. Each node represents a unique relation type from the source knowledge graph, and edges capture co-occurrence patterns between relations. We use this approach for all benchmark datasets. Table 1 summarizes the statistics of the constructed relation-based model graphs, including the number of entities and relations in the original knowledge graph, as well as the corresponding nodes and edges in the model graph.

4.1.0.2 Entity-Based Model Graph.

This construction requires explicit entity type annotations. Each node represents an entity type, and edges capture relational patterns between entity types. We apply this approach to the Hetionet dataset from [28], a biomedical knowledge graph where detailed entity type information is available.

4.2 Task Sampling Strategy↩︎

We adopt the subgraph sampling strategy detailed in Section 3.3, inspired by MorsE [29]. This episodic construction is applied during both training and evaluation.

4.3 Implementation Details↩︎

We implement MGIL using PyTorch [30] and DGL [31]. For the inductive link prediction task, we utilize a combination of a GNN for node embeddings and an R-GCN applied to the task graph. To ensure robustness, all reported results are averaged over 5 independent runs with different seeds. The low variance across runs confirms the stability of our method. Detailed hyperparameters, hardware specifications, and baseline configurations are provided in Appendix 6.

4.4 Datasets↩︎

We evaluate MGIL on two groups of inductive benchmark datasets.

Standard inductive benchmarks. The first group comprises inductive variants of WN18RR [32], FB15k-237 [33], and NELL-995 [34], constructed following the inductive evaluation protocol proposed by [11]. Under this protocol, the original knowledge graph is partitioned into two entity-disjoint subgraphs: a source graph used for training and a target graph used for evaluation. The target graph contains entities unseen during training, requiring models to generalize inductively. Each benchmark provides four variants (v1–v4) with increasing graph sparsity and structural complexity.

Recently proposed inductive benchmarks. The second group consists of three benchmarks introduced by [28]: CoDEx-M, WN18RR (Shomer et al. split), and HetioNet. These benchmarks are specifically designed to provide a stricter inductive evaluation setting by ensuring that entities in the test set are disjoint from those observed during training, while also reducing structural overlap between the training and test graphs.

As discussed by [28], such design choices mitigate information leakage and limit the ability of models to rely on memorization of entity-specific patterns. Instead, models are required to generalize based on relational and structural patterns present in the graph.

Therefore, these datasets offer a more realistic and challenging benchmark for inductive link prediction, and are particularly well aligned with our approach, which emphasizes learning transferable structural representations through the model graph.

4.5 Evaluation Protocol↩︎

We evaluate the performance of MGIL on the inductive link prediction task. In this setting, entities appearing in the test set may not have been observed during training, and their embeddings must be constructed at inference time.

4.5.0.1 Inductive entity embedding.

For unseen entities in the test set, embeddings are generated using the relation-based model graph. Specifically, for a given entity, we first extract its incident relations (both incoming and outgoing) from the test graph and construct its feature vector following the encoding scheme described in Section 3.3.

If a node with an identical feature vector exists in the model graph, its embedding is directly used to initialize the entity representation. Otherwise, we identify the most similar node by computing the Hamming distance between feature vectors and select the closest match. The embedding of this nearest node is then used as the initial representation. This procedure enables generalization to unseen entities without requiring retraining.

4.5.0.2 Evaluation metrics.

We report two standard ranking-based metrics: Mean Reciprocal Rank (MRR) and Hits@10 (H@10). Hits@10 measures the proportion of test queries for which the correct entity is ranked within the top-10 predictions, while MRR captures the average reciprocal rank of the correct entity.

4.5.0.3 Ranking protocol.

For each test triple \((h, r, t)\), we perform both head prediction \((?, r, t)\) and tail prediction \((h, r, ?)\) by ranking the correct entity against 50 randomly sampled negative entities. This sampled evaluation protocol is adopted for computational efficiency.

To ensure fair evaluation, we apply a filtered setting within the sampled candidates by removing any negative samples that correspond to known true triples in the training, validation, or test sets.

This sampling procedure is repeated five times with different random seeds. For each run, results are averaged over head and tail prediction tasks, and the final reported performance is obtained by averaging across all runs.

4.6 Baselines↩︎

We compare MGIL against representative inductive knowledge graph reasoning methods, categorized into three groups: rule-learning-based methods, subgraph-based GNN methods, and neural message-passing approaches.

4.6.0.1 Rule-learning-based methods.

This category includes RuleN [21], which explicitly extracts logical rules from knowledge graphs. In addition, Neural-LP [22] and DRUM [23] learn logical rules in an end-to-end differentiable framework, enabling gradient-based optimization of rule structures.

4.6.0.2 Subgraph-based GNN methods.

GraIL [11] performs inductive reasoning by extracting enclosing subgraphs around target links and applying graph neural networks for relation prediction. CoMPILE [26] improves upon GraIL by introducing communicative message passing to enhance subgraph representation learning. MorsE [29] further extends this line of work by leveraging meta-learning (MAML) to adapt across task-specific subgraphs.

4.6.0.3 Neural message-passing methods.

This category includes approaches based on relational graph neural networks, such as R-GCN [24], which perform message passing over relational graphs to learn entity representations through multi-hop aggregation. We additionally compare with NBFNet [35], which formulates relational reasoning as a generalized neural Bellman-Ford message passing framework. By explicitly modeling path-based dependencies, NBFNet effectively captures multi-hop relational patterns and has demonstrated strong performance on link prediction benchmarks.

4.6.0.4 Evaluation protocol.

For all baselines, we report results as published in their original papers, following the corresponding inductive evaluation protocols. While the specific evaluation settings (e.g., number of negative samples) may vary across methods, all results are based on the Hits@10 metric for link prediction on the same benchmark datasets, enabling meaningful comparison of inductive reasoning performance.

4.7 Result Analysis↩︎

We evaluate MGIL under two model graph configurations and two experimental settings. For the relation-based model graph (denoted as MGIL\(_r\)), which does not require entity type information, we conduct experiments on: (i) standard inductive benchmarks widely adopted in prior literature, and (ii) the more challenging inductive splits recently proposed by [28]. For the entity-based model graph (denoted as MGIL\(_e\)), which requires entity type information, we evaluate only on the Hetionet dataset from [28], as it provides sufficient entity type annotations necessary for this configuration. To avoid conflating evaluation protocols, we analyze these settings independently.

Table 2 reports performance on standard inductive benchmarks using MGIL\(_r\), including WN18RR-V1–V4, FB15k-237-V1–V4, and NELL-995-V1–V4. These datasets follow conventional entity-disjoint inductive splits established in prior work.

Under this evaluation protocol, MGIL\(_r\) consistently achieves competitive or superior performance compared to existing baselines across all variants. Unlike rule-based methods that rely on explicit structural heuristics, MGIL\(_r\) learns transferable structural representations directly from graph topology through its meta-learning framework, enabling effective generalization to unseen entities.

Across different dataset families and split versions (V1–V4), MGIL\(_r\) maintains consistent performance, demonstrating robustness to variations in graph density and structural patterns. This consistency suggests that the framework effectively captures inductive structural signals that generalize to unseen entities without dataset-specific adaptations.

3pt

Table 3 presents the results on the recently introduced benchmarks of [28], which define stricter inference splits (Inference 1 and Inference 2) designed to better simulate realistic inductive scenarios. These results are obtained using the relation-based model graph.

On CoDEx-M, MGIL\(_r\) achieves 70.11, significantly outperforming prior supervised baselines such as NBFNet (43.6) and RED-GNN (35.6). This result demonstrates the ability of MGIL to generalize structural knowledge under the revised inductive protocol.

On WN18RR, MGIL\(_r\) achieves 75.37 in the Inference 1 setting and 75.91 in the more challenging Inference 2 setting, outperforming all competing methods. Notably, the performance remains stable across both settings, indicating strong robustness under stricter entity-disjoint conditions.

On HetioNet, MGIL\(_r\) achieves the best performance in both inference settings, with scores of 86.12 (Inference 1) and 90.84 (Inference 2), surpassing all baseline methods. Given the structural complexity and heterogeneity of HetioNet, these results further confirm the effectiveness of the proposed framework in handling diverse knowledge graph structures.

Table 4 presents the MRR performance of MGIL\(_r\) (relation-based configuration) on Shomer et al. benchmarks, which evaluate inductive link prediction under challenging structural distribution shifts.

On CoDEx-M Inference 1, MGIL\(_r\) achieves an MRR of 52.14, substantially outperforming all baselines including NBFNet (27.6) and RED-GNN (22.1), indicating robust handling of unseen relational patterns.

On WN18RR, the results show mixed performance across inference settings. In Inference 1, MGIL\(_r\) achieves 58.5, which is lower than RED-GNN (67.8) and NBFNet (66.6). However, in the more challenging Inference 2 setting, MGIL\(_r\) achieves 20.31, modestly outperforming NBFNet (17.6) and RED-GNN (16.4), demonstrating improved robustness under stricter entity-disjoint conditions.

On Hetionet, MGIL\(_r\) achieves competitive performance in Inference 1 (55.53, slightly above RED-GNN’s 53.8) and the highest MRR in Inference 2 (71.36), substantially surpassing RED-GNN (68.6) and NBFNet (45.2). These results highlight MGIL’s ability to leverage meta-learned structural priors from the model graph for effective generalization to structurally distinct target graphs, particularly in highly heterogeneous domains. generalization to structurally distinct target graphs.

To evaluate the effectiveness of the entity-based model graph configuration, we conduct additional experiments on Hetionet, which provides entity type annotations required for this setup. Unlike the relation-based model graph used across all datasets, the entity-based variant constructs meta-relations based on entity types rather than relation types. Table 5 presents the results across two inference runs with different random seeds.

With the entity-based model graph, MGIL achieves 90.05% and 90.57% on the two inference runs, outperforming all baselines including the strongest competitor MorsE. These results demonstrate that when entity type information is available, the entity-based model graph configuration can effectively capture entity-level patterns and further enhance inductive reasoning performance. The consistent performance across both inference runs confirms the robustness of this configuration for heterogeneous knowledge graphs with rich entity type annotations.

Overall, the results across both settings demonstrate that MGIL performs reliably under conventional inductive benchmarks and exhibits even stronger advantages under the more challenging splits introduced by Shomer et al. This separation of evaluation protocols ensures a fair and transparent comparison while highlighting the inductive robustness of the proposed approach.

5 Conclusion↩︎

In this paper, we introduced Model Graph Inductive Learning (MGIL), a novel framework for inductive knowledge graph completion that leverages a higher-level abstraction of the original knowledge graph, referred to as the model graph. By transforming entities or relations into compact and semantically meaningful nodes, the proposed approach captures global structural patterns that are often overlooked by purely local message-passing methods.

Unlike conventional inductive approaches that rely primarily on subgraph sampling or neighborhood aggregation, MGIL enhances representation learning by incorporating structural regularities at the model graph level. In particular, embeddings learned over the model graph provide a meaningful and informed initialization for entity representations, which facilitates more effective and stable GNN-based message passing in subsequent stages. This leads to improved generalization to unseen entities and relations, particularly in sparse or low-resource scenarios.

Extensive experiments on multiple inductive benchmarks, including CoDEx-M E, WN18RR E, and HetioNet E, demonstrate the effectiveness of the proposed framework. The results show that MGIL consistently outperforms strong baselines, highlighting the importance of incorporating global structural information into inductive reasoning.

Furthermore, the flexibility of the model graph construction ,such as relation-based and entity-type-based variants , provides a unified perspective for capturing different aspects of knowledge graphs. Beyond simple abstractions, the model graph can be extended to more expressive forms, such as directed and weighted structures, or even multi-relational graphs, enabling richer representations of dependencies between abstract nodes.

Overall, MGIL provides a principled framework for bridging local and global reasoning in knowledge graph completion.

6 Experimental and Implementation Details↩︎

To ensure the reproducibility and transparency of our experiments, we provide detailed descriptions of the implementation, datasets, baseline configurations, and training procedures.

6.1 Hardware and Frameworks↩︎

All experiments are conducted on a single NVIDIA RTX 3090 GPU with 24GB of VRAM. Our models are implemented using PyTorch [30] and DGL [31].

6.2 Baseline Configurations and Fair Comparison↩︎

We follow a strict protocol to ensure fair and meaningful comparisons with prior work. In particular, for baseline models such as MORSE, we adhere to the original experimental settings, evaluation protocols, and hyperparameter configurations reported in their respective papers.

To avoid any potential data leakage, all evaluations are conducted on the official dataset splits provided by each benchmark, without any modification or subgraph resampling.

6.3 Model Architecture and Hyperparameters↩︎

Our framework consists of two main components: a model graph encoder and a task-specific reasoning module.

First, we apply a 2-layer GNN on the model graph to obtain node embeddings of dimension \(d=32\). These embeddings are then used to parameterize relation-specific transformations in a downstream R-GCN applied to the task graph.

Depending on the dataset, we use either a 2-layer or 3-layer R-GCN, with all hidden and embedding dimensions fixed to 32. To regularize relation-specific parameters and reduce model complexity, we adopt the basis decomposition technique proposed by Schlichtkrull et al. [24], using \(B \in \{3,4\}\) bases depending on the number of relations.

To ensure a well-grounded experimental setup, our hyperparameter choices are informed by prior state-of-the-art studies, particularly MORSE and NBFNet, which demonstrate strong empirical performance under comparable hardware and evaluation settings. We use their reported configurations and publicly available implementations as a reference point, and introduce only minimal modifications where necessary to align with our model design.

The training configuration is as follows: batch size of 64 tasks, learning rate of 0.01, and 10 training epochs. We use a fixed margin \(\gamma=10\) and uniformly sample \(\beta=32\) negative entities per positive triple.

6.4 Task Generation↩︎

We generate training and validation tasks using a random-walk-based procedure. For each dataset, we construct 10,000 training tasks and 200 validation tasks.

The random walk parameters are set to walk length \(l_{rw}=5\), number of walks per entity \(n_{rw}=10\), and anonymization ratio \(t_{rw}=10\). This process ensures that task graphs capture local structural patterns while maintaining diversity across tasks.

6.5 Dataset Statistics for the Second Benchmark↩︎

In this section, we provide detailed statistics for the datasets used in our inductive link prediction benchmark.

6.5.1 Statistics for the New Inductive Datasets↩︎

Table 6 reports statistics for CoDEx-M, WN18RR (Shomer et al. split), and HetioNet. For each dataset, we provide the number of edges, entities, and relations for both training and inference splits.

6.5.2 Statistics for Standard Inductive Benchmarks↩︎

Due to space limitations in the main paper, we use abbreviated dataset names (e.g., W1 for WN18RR version 1). Table 7 provides detailed statistics for multiple versions of WN18RR (W), FB15k-237 (F), and NELL-995 (N), including both source and target graphs.

These datasets span a wide range of inductive scenarios, from minor shifts in entity sets to substantial structural differences between source and target graphs, enabling a comprehensive evaluation of inductive generalization.

6.6 Computational Complexity Discussion↩︎

The proposed framework employs a standard GCN on the model graph and an R-GCN on sampled subgraphs. Although both architectures follow a message-passing paradigm, their computational costs differ in structure.

For a standard GCN applied to a graph with \(|\mathcal{V}|\) nodes and \(|\mathcal{E}|\) edges, the per-layer complexity is: \[\mathcal{O}(|\mathcal{E}| d + |\mathcal{V}| d^2),\] where \(d\) is the embedding dimension.

In contrast, R-GCN introduces relation-specific transformations. For a graph with \(|\mathcal{R}|\) relation types, the per-layer complexity becomes: \[\mathcal{O}(|\mathcal{E}| d + |\mathcal{R}| |\mathcal{V}| d^2),\] due to the use of distinct weight matrices for each relation.

However, in our framework, R-GCN is applied only to small sampled subgraphs rather than the full knowledge graph. Since \(|\mathcal{V}_s|\) and \(|\mathcal{E}_s|\) are significantly smaller than those of the original graph, the overall computational cost remains manageable in practice.

Regarding the size of the model graph, each node represents a group of entities sharing identical relational feature vectors. Therefore, the number of model nodes satisfies: \[|\mathcal{V}_m| \leq |\mathcal{V}|.\]

In practice, the model graph is often more compact than the original graph, as multiple entities may share the same relational patterns and are thus mapped to the same node. However, the degree of this compression depends on the diversity of relational features in the dataset. In cases where entity features are highly unique, the size of the model graph may approach that of the original graph.

References↩︎