JGURD: joint gradient update relational direction-enhanced method for knowledge graph completion

Construction of KG and RCG

A KG is represented as a directed multi-relational graph, where nodes represent entities, edges represent relationships between entities. The graph is a multi-typed edge structure that supports multiple edge types between the same node pairs and allows self-loops (i.e., nodes can connect to themselves through specific relationships). A triple is converted into a graph by mapping the head and tail entities to two nodes, with the relationship represented as a directed edge from the head to the tail. For multiple relationships or self-loops, corresponding edges are added to ensure the graph fully captures the semantic and topological structure of the KG.

To model topological patterns between any two adjacent relationships, this article categorizes all adjacent relationships into six topological patterns, as illustrated in Fig. 3. The left part of the figure shows two relationships from adjacent triples and their connection to central entity, with arrows indicating the directionality of relationships. The topological pattern between $r_1$ and $r_2$ is determined by their directional connection to the central entity. For instance, if $r_1$ is an incoming relationship to the central entity and $r_2$ is an outcoming relationship from the central entity, the pattern is Input-to-Output (I-O). Six relational topological patterns are identified: Input-to-Output (I-O), Output-to-Output (O-O), Input-to-Input (I-I), Output-to-Input (O-I), Similar (SIM), and Inverse (INV). All adjacent triples fit into one of these categories. The right part of the figure illustrates their corresponding representations in the RCG obtained from the transformed KG, where nodes $r_1$ and $r_2$ represent the relationships from the KG, and the labeled arrow from $r_1$ to $r_2$ denotes topological pattern.

To facilitate the learning of relationship embeddings, an original KG is transformed into RCG based on the classification of topological patterns between relationships. As shown Fig. 4, the left side of the figure illustrates a subgraph of the original KG, where $u$, $v$, $e_1$, and $e_2$ represent entities, and $r_1,r_2,r_3,r_4,r_5,r_6$ represent relationships. The dashed line indicates the central node $r_t$, which represents a specific relationship in the original KG. The right side shows the transformed RCG, where nodes represent relationships from the original KG, rather than entities. The central node $r_t$ connects to other nodes $r_1,r_2,\dots ,r_6$. The edges in the RCG capture the topological patterns between relationships, such as Input-to-Output (I-O), Output-to-Output (O-O), and so on, reflecting the directional connections between them.

For a KG dataset, the construction process of the RCG is similar to that of the KG, except that nodes in RCG represent relationships from original KG rather than entities. In the construction of RCG, all relationships are first extracted from the KG and added as nodes in the RCG. Then, by analyzing the topological patterns between relationships, edges are established between nodes to reflect the directional connections between relationships. During this process, relationship patterns that may cause self-loops are excluded, ensuring that no self-loops appear in the RCG.

Multi-relation and entity encoding mechanism

After KG and RCG are represented as graph structures, the vector representations of each entity and relationship are initialized as the starting point for model learning. This article employs a Gaussian distribution (Wu et al., 2024; Fei et al., 2024) to randomly initialize embeddings for entities and relationships, ensuring randomness and diversity. Although the initial embeddings do not capture semantic and structural information of KGs, they provide the basic input for subsequent learning. The randomly initialized embeddings are refined by encoders and iteratively optimized during model training to more accurately capture the semantic relationships and topological features of KG.

Gradient descent update rule

Figure 5 illustrates that VR-GCN, which uses a vector relationship GCN, only updates entity embeddings without considering relationship embeddings. CompGCN uses composition operators, TransGCN introduces a new heterogeneous neighborhood representation method. Although they both learn embeddings for entities and relationships simultaneously, they do not take into account the feature representation of neighbor entities when updating relationships. The proposed JGURD employs convolutional operations for both entity and relationship feature representations. Additionally, it incorporates entity neighborhood information for relationship feature updates and defines similar updating methods for both entities and relationships. Note that during the joint gradient update process, nodes denote entities in KGs.

Updating entity and relationship embeddings jointly with similar methods improve model consistency and interpretability. JGURD introduces scoring function $f(\cdot )$ to evaluate triple rationality, which is crucial for identifying factual triples. The embedding and updating of multi-layer nodes are shown in Eqs. (13) and (14).

(13) $$m_v^{(l+1)}=\sum _{u\in N(v)}\frac{\mathrm{\partial }f\left(e_u^{(l)},e_v^{(l)}\right)}{\mathrm{\partial }{e}_v^{(l)}}$$

(14) $$e_v^{(l+1)}=\sigma \left(W^{(l)}\left(m_v^{(l+1)}+e_v^{(l)}\right)\right)$$where $e_v^{(l)}$ denotes the embedding of node $v$ at layer l, $N(v)$ denotes the set of neighbor nodes of $v$, $m_v^{(l+1)}$ represents the aggregated representation of these neighbors. Constraining $f(\cdot )$ to be the inner product of the head and tail entities, i.e., $f\left(e_u,e_v\right)=e_u^T{e}_v$, the gradient of $m_v^{(l+1)}+e_v^{(l)}$ will increase further, and the sum of the triple scoring functions within the neighborhood, $\sum f\left(e_u,e_v\right)$, can be maximized.

In multi-relational graphs, relationship embedding is crucial for the scoring function that measures the rationality of triples, which is often ignored by most GCN-based KGC methods. To apply similar update rules and methods for entities and relationships, their feature representations should be learned jointly. By incorporating relationship embeddings and categorizing the directions of relationship as incoming and outgoing, the entity update rule in Eq. (13) is defined as follows:

(15) $$m_v^{(l+1)}=\sum _{(u,r)\in N_{in}(v)}{W}_e^{(l)}\frac{\mathrm{\partial }{f}_{\mathrm{i}\mathrm{n}}\left(e_u^{(l)},e_r^{(l)},e_v^{(l)}\right)}{\mathrm{\partial }{e}_v^{(l)}}+\sum _{(u,r)\in N_{\mathrm{o}\mathrm{u}\mathrm{t}}(v)}{W}_e^{(l)}\frac{\mathrm{\partial }{f}_{\mathrm{o}\mathrm{u}\mathrm{t}}\left(e_v^{(l)},e_r^{(l)},e_u^{(l)}\right)}{\mathrm{\partial }{e}_v^{(l)}}$$

(16) $$e_v^{(l+1)}=\sigma \left(m_v^{(l+1)}+W_{se}^{(l)}{e}_v^{(l)}\right).$$

In Eq. (15), $N_{in}(v)$ denotes the set of incoming neighbors for node $v$, and $N_{out}(v)$ denotes the set of outgoing neighbors for node $v$. $W_{se}$ is the self-loop update weight matrix for an entity. Equation (16) indicates that the entity’s final feature representation is derived from the message passing and self-loop message.

As illustrated in Fig. 6, the blue entities represent the entities within the $N_{in}(v)$ set, while the purple entities represent the entities within the $N_{out}(v)$ set. Similarly, the relationship update rule, which takes into account entity neighborhood information, is defined as follows:

(17) $$m_r^{(l+1)}=\sum _{(u,v)\in N(r)}{W}_r^{(l)}\frac{\mathrm{\partial }{f}_r\left(e_u^{(l)},e_r^{(l)},e_v^{(l)}\right)}{\mathrm{\partial }{e}_r^{(l)}}$$

(18) $$e_r^{(l+1)}=\sigma \left(m_r^{(l+1)}+W_{sr}^{(l)}{e}_r^{(l)}\right)$$where $N(r)$ denotes the direct neighbor set of relationship $r$, including the head entity and tail entity in the triple. $W_{sr}$ is the self-loop update weight matrix of a relationship.

Figure 7 illustrates the updating process of JGURD. On the left side of the figure, the scoring function $f(\cdot )$ is used to evaluate the quality of each triple, where each triple consists of entity nodes (e.g., $u_1,u_2,u_3$) and a relationship (e.g., $r_1,r_2,r_3$). This scoring function calculates the score for each triple and serves as the basis for updating the embeddings of both entities and relationships. The right side of the figure shows how the gradients of the scoring function are computed and used to update the embeddings. Specifically:

• $F_v=\mathrm{\partial }f/\mathrm{\partial }v$ is the gradient used to update the embedding of the central entity $v$. It is calculated based on the influence of its connected relationships $r_1,r_2,r_3$ and neighboring entity (e.g., $u_1,u_2,u_3$).

• For the relationship $r_k$, its gradient $F_{r_k}=\mathrm{\partial }f/\mathrm{\partial }{r}_k$ depends not only on the relationship itself but also on the embeddings of the entity connected to it. Specifically, the update of $r_k$ is influenced by the gradient propagation from its connected entity nodes (e.g., $u_k$ and $v$), where $k=1,2,3,\dots$. This ensures that the update of the relationship reflects the influence of entities.

• For the entity $u_k$, its gradient $F_{u_k}=\mathrm{\partial }f/\mathrm{\partial }{u}_k$ represents the interactions between the entity node, its associated relationship $r_k$, and other entity nodes, where $k=1,2,3,\dots$.

This joint gradient update mechanism ensures mutual interaction between the embeddings of entities and relationships during the update process.

To achieve training consistency, this article makes $f_{\mathrm{i}\mathrm{n}}=f_{\mathrm{o}\mathrm{u}\mathrm{t}}=f_r$ in the calculation of triple score and uses a uniform weight matrix, $W_e^{(l)}=W_r^{(l)}$. In graph neural networks, entity and relationship node representations tend to be dominated by neighbor node information through iterative message passing and updates, potentially leading to distortion in node representation. To tackle this issue, different self-loop update weight matrices are added for the entities and relationships, that is, $W_{se}^{(l)}\ne W_{sr}^{(l)}$. This ensures their self-information can be preserved in each update round, enhancing the robustness of their representations. To prevent numerical instability, gradient explosion, and gradient vanishing, we introduced normalization factors for both entities and relationships. Replace $m_v^{(l+1)}$ with $\alpha m_v^{(l+1)}/\left(\left|N_{\mathrm{i}\mathrm{n}}(v)\right|+\left|N_{\mathrm{o}\mathrm{u}\mathrm{t}}(v)\right|\right)$ in Eq. (16). Replace $m_r^{(l+1)}$ with $\beta m_r^{(l+1)}/|N(r)|$ in Eq. (18). $|\cdot |$ represents the number of elements in set, $\alpha$ and $\beta$ are hyperparameters controlling the weight of aggregated neighboring information.

Multi-decoder layer

Different decoders employ diverse scoring and loss functions, enriching a model’s expressive capabilities and enhancing its understanding of complex relationships between entities. This article attempts three decoders, including TransE, RotatE, and DistMult. They are individually designed, implemented, refined, and integrated into the entire architecture of JGURD to find the most suitable one.

• Decoder 1: JGURD-TransE

As a kind of distance translation-based model, TransE assums that the relationship serves as the translation between the head entity and the tail entity. For the triple $\left(e_u,e_r,e_v\right)$, scoring function is defined by Eq. (19).

(19) $$f_{e_r}(e_u,e_v)=-\parallel e_u+e_r-e_v\parallel$$where $e_u$, $e_r$, and $e_v$ represent the head entity vector, relationship vector, and tail entity vector, respectively. To further optimize JGURD, this article adopts the Bernoulli negative sampling (Yang et al., 2024; Yao et al., 2023) method to construct a certain number of negative samples. The margin-based ranking loss function is shown in Eq. (20).

(20) $$L=\sum _{\left(e_u,e_r,e_v\right)\in T}\sum _{\left(e_u^{\mathrm{\prime }},e_r,e_v^{\mathrm{\prime }}\right)\in T^{\mathrm{\prime }}}max\left(0,-f_{e_r}\left(e_u,e_v\right)+f_{e_r}\left(e_u^{\mathrm{\prime }},e_v^{\mathrm{\prime }}\right)+\gamma \right)$$where T denotes the set of factual triples, $T^{\mathrm{\prime }}$ represents the set of negative triples, $max(a,b)$ represents the maximum value of $a$ and $b$, and $\gamma$ is the margin parameter.

• Decoder 2: JGURD-RotatE

The second decoder is based on rotational hypothesis. RotatE incorporates knowledge from complex vector spaces, rotating entities within this space, and deriving tail entities from head entities. The scoring function is defined by Eq. (21).

(21) $$f_{e_r}\left(e_u,e_v\right)=-\parallel e_u\odot e_r-e_v\parallel$$

Self-adversarial negative sampling is used to train JGURD, it employs a probability distribution to generate negative samples (Kamigaito & Hayashi, 2022). Assuming $\left(u_i^{\mathrm{\prime }},e_r,v_i^{\mathrm{\prime }}\right)$ is the negative sample for the triple $\left(u_i,e_r,v_i\right)$, the probability distribution $p$ for other negative sample triples $\left(u_i^{\mathrm{\prime }},e_r,v_i^{\mathrm{\prime }}\right)$ is given by Eq. (22).

(22) $$p({u_j}^{\mathrm{\prime }},e_r,{v_j}^{\mathrm{\prime }})=\frac{\exp (\alpha f_{e_r}({u_j}^{\mathrm{\prime }},{v_j}^{\mathrm{\prime }}))}{\sum _{({u_i}^{\mathrm{\prime }},e_r,{v_i}^{\mathrm{\prime }})\in T^{\mathrm{\prime }}}\exp (\alpha f_{e_r}({u_i}^{\mathrm{\prime }},{v_i}^{\mathrm{\prime }}))}$$where $\alpha$ is a constant. Based on the probability weights of the aforementioned negative samples, the loss function is set as shown in Eq. (23). $\sigma$ denotes the sigmoid activation function, and the embeddings of entities and relationships are both in the complex vector space.

(23) $$L=-\log \left(\sigma \left(\gamma +f_{e_r}\left(e_u,e_v\right)\right)\right)-\sum _{\left({e_u}^{\mathrm{\prime }},e_r,{e_v}^{\mathrm{\prime }}\right)\in T^{\mathrm{\prime }}}p\left({e_u}^{\mathrm{\prime }},e_r,{e_v}^{\mathrm{\prime }}\right)\log \left(\sigma \left(-f_{e_r}\left({e_u}^{\mathrm{\prime }},{e_v}^{\mathrm{\prime }}\right)-\gamma \right)\right).$$

• Decoder 3: JGURD-DistMult

Lastly, based on the hypothesis of bilinear scoring function, DistMult enhances the connections between entities and relationships. It utilizes a two-dimensional diagonal matrix operator $M_{e_r}$ to replace the tensor matrix. The scoring function is shown in Eq. (24).

(24) $$f_{e_r}\left({\mathbf{e}}_u,{\mathbf{e}}_v\right)={\mathbf{e}}_u^T{M}_{e_r}{\mathbf{e}}_v.$$

The Bernoulli negative sampling method is used to construct negative samples, and the minimized cross-entropy loss function is shown in Eq. (25).

(25) $$L=-\frac{1}{(1+\omega )\left|{\epsilon }^{\mathrm{\prime }}\right|}\sum _{\left(e_u,e_r,e_v\right)\in T}y\log \sigma \left(f_{e_r}\left(e_u,e_v\right)\right)+(1-y)\log \left(1-\sigma \left(f_{e_r}\left(e_u,e_v\right)\right)\right)$$where $\omega$ is the number of negative samples, ${\epsilon }^{\mathrm{\prime }}$ is the entity sampling range, and $y$ is the label added to factual triples and negative sample triples (1 or 0). $\sigma (\cdot )$ denotes the sigmoid activation function.

Training

This article employs the point-wise cross-entropy loss function (Ji et al., 2021) to update stage parameters. It disregards sample order and introduces probability $p$ from the binomial distribution to label positive and negative triples. By minimizing the loss function, the scores of positive triples are maximized while the scores of negative triples are minimized. The loss function is shown in Eq. (26).

(26) $$L=-\frac{1}{S}\sum _{\left(e_u,e_r,e_v\right)\in T}\sum _{i=1}^S\left[y_i\log {\hat{y}}_i+\left(1-y_i\right)\log \left(1-{\hat{y}}_i\right)\right]$$where S represents the batch size of training, T is the set of triples, $y_i$ denotes the label of triple $f_i\left(e_u,e_r,e_v\right)$, taking values of 1 or 0, and ${\hat{y}}_i$ denotes the mapping result after applying the softmax function.

(27) $${\hat{y}}_i=g\left(f_i\left(e_u,e_r,e_v\right)\right)$$where $g(\cdot )$ denotes the softmax function and $f(\cdot )$ denotes the score function of the triple.

Datasets and evaluation metrics

This article carries out experiments on FB15K (Bordes et al., 2013), FB15k-237 (Bordes et al., 2013), WN18RR (Dettmers et al., 2018), and NELL-995 (Xiong et al., 2018) datasets. Models can predict most triples effortlessly when there are numerous reversible relationships in a dataset, bring excessive evaluation benchmarks. To avoid this issue, the FB15k-237 and WN18RR datasets were created by eliminating the inverse relationships in FB15k and WN18. WN18 dataset URL is https://paperswithcode.com/dataset/wn18 and FB15k dataset URL is https://everest.hds.utc.fr/doku.php?id=en:transe. The NELL-995 dataset is derived from the 995th iteration of the NELL system, consisting of triples with the 200 most frequent relationships. NELL-995 dataset URL is https://rtw.ml.cmu.edu/rtw/. As shown in Table 1, this article divides datasets into training, validation, and test sets. $|\mathbf{V}|$ and $|\mathbf{E}|$ represent the number of entities and relationships, respectively.

We utilize the PyTorch and DGL frameworks, employing the Adam optimizer for gradient descent algorithm. The vector dimensions are set to 100 for datasets FB15k, FB15k-237, and NELL-995, and 50 for WN18RR. The learning rate is 0.001, batch size is 64, encoder training epochs are 500, dropout rate is 0.3. The number of graph convolutional layers is set to 1, while the number of attention layers is set to 3.

In our experimental evaluation, we employed mean reciprocal rank (MRR) and the Hits@N metric, with N values of 1, 3, and 10.

Figure 8 is a complete workflow diagram to illustrate how data is processed, split, and used during training, validation, and testing. The original dataset was cleaned and checked for outliers, and subsequently split into training, validation, and test sets. As the dataset is publicly available, the splitting has been previously performed by other researchers following a common proportion (Wei, Song & Yao, 2024; Luo & Song, 2024). The link to the partitioned data is https://github.com/Lemen569/rawdata_JGURD. The details of the split are provided in Table 1. The training set, after applying different negative sampling strategies, uses a subset of negative samples along with positive samples for model training. The validation set is then used for hyperparameter tuning and model validation, while the test set is used for final model testing. The model performance is ultimately evaluated through the Hits@1, 3, 10, and MRR metrics.

In training, negative sample generation is crucial for model training. It occurs before each training epoch, during the data preparation phase, ensuring that both negative and positive samples are included in the training process, rather than being dynamically generated during model training or evaluation. From the perspective of the generation method, the Bernoulli negative sampling strategy is used for TransE and DistMult decoders. Based on the relation characteristics of each positive sample (e.g., 1-N or N-1), the Bernoulli distribution determines whether to replace a head or tail entity. Each positive sample generates multiple negative samples to enhance training diversity. For the RotatE decoder, a model-based self-adversarial negative sampling strategy is employed. Candidate negative samples are scored, and those with higher scores are selected based on the softmax-derived distribution. In addition, the generation of negative samples is restricted to the training set. During the entire training process, the validation and test sets are not involved in negative sample generation, ensuring their independence and effectively preventing data leakage.

Comparison experiments

We compare JGURD with 14 related models by experiments on four public datasets and the results are listed in Tables 2 and 3. The bold number presents the best result, the underlined number presents the second-ranked result, and the dash indicates the original reference didn’t supply according experiment result.

We can observe that JGURD overall outperforms other models across all metrics. On the FB15k dataset, the JGURD achieves 6.8% and 8.9%, higher results than the second-place method (HHAN-KGC) on Hits@3 and MRR, respectively. This advantage may stem from JGURD’s multi-relation encoding mechanism, which models complex relational associations via RCG and enhances entity feature learning through a relation-aware entity encoder. In contrast to HHAN-KGC, which uses hyperbolic space and hierarchical attention mechanisms to model complex relations, JGURD shows clear superiority in handling intricate relational patterns. Meanwhile, the FB15k dataset contains 1,345 relations and diverse relational patterns (1-N, N-1, N-N), providing ample modeling space for JGURD’s RCG mechanism and further enhancing its performance.

In addition, both JGURD and TACT use RCG, the original reference of TACT only supplied the values of Hits@1 and MRR on two datasets, i.e., WN18RR and FB15k-237. To compare JGURD and TACT comprehensively, we have complemented TACT’s Hits@3 and Hist@10 on WN18RR and FB15k-237, and Hit@1, Hit@3, Hit@10 and MRR on FB15k and NELL-995 in Tables 2 and 3. JGURD is superior to TACT on all three datasets except WN18RR. It is because the scarcity of relationships in WN18RR cannot supply sufficient information in the topological structure of relationships when JGURD aggregates relationships in the RCG. However, on other three datasets, JGURD demonstrates a significant advantage. For instance, compared to TACT, JGURD showed increases of 17.9%, 6.6%, and 3.0% in Hits@3, Hits@10, and MRR on the FB15k-237 dataset, respectively, indicating that the performance improvement of JGURD is primarily due to its model design. For example, JGURD’s joint gradient update mechanism enhances the model’s ability to capture dynamic entity-relationship interactions and enables efficient adaptation to the heterogeneous structures and feature distributions of different datasets. This adaptability allows JGURD to achieve significant performance gains across various datasets. On datasets like FB15k-237 and NELL-995, JGURD outperforms all other methods. Even on the relation-sparse WN18RR dataset, its innovative framework outperforms most comparison models. In the WN18RR dataset, its joint gradient update mechanism extracts more meaningful feature representations from sparse relational data, enhancing its robustness and accuracy in completion tasks.

Moreover, some baseline models exhibit significant performance differences across datasets with sparse relationships (WN18RR) and those with denser relationships (FB15k, FB15k-237, and NELL-995). For instance, models like SACN, TACT and CTKGC perform notably worse on the other three datasets compared to WN18RR, indicating they are heavily influenced by dataset distribution. In contrast, our JGURD model shows smaller performance differences across these four datasets and is less affected by distribution characteristics, exhibiting relatively better generalization ability.

Finally, as shown in Tables 2 and 3, the RotatE decoder in JGURD’s multi-decoder mechanism outperforms the others. This is mainly due to its ability to model complex relational patterns effectively through rotation operations in the complex plane, particularly excelling on datasets such as FB15k-237 and FB15k, which include symmetric and antisymmetric relationships. Additionally, the TransE and DistMult decoders each have distinct advantages: TransE excels at modeling one-to-one relations, while DistMult performs well with symmetric relations. This multi-scoring function strategy allows JGURD to adapt flexibly to the feature distributions of different datasets, thereby enhancing its robustness.

To further validate the effectiveness of the joint gradient update method put forward by us, we also compare JGURD with VR-GCN, CompGCN, and TransGCN on FB15k-237. As shown in Table 4, JGURD perform best. In particular, JGURD-RotatE achieves a Hits@10 improvement of approximately 9.3% over CompGCN and 5.4% over TransGCN. This advantage stems from JGURD’s joint gradient update mechanism, which integrates local neighborhood entity information during relationship updates. Through iterative updates using forward propagation gradients of entities and relationships, it facilitates dynamic interaction and collaboration between entity and relationship representations, optimizing model parameters. In contrast, while CompGCN and TransGCN jointly consider entities and relationships using combination operators, they do not leverage entity feature representations in the neighborhood to update relationships. This weakens the coordination between entity and relationship representations, limiting model performance.

Ablation experiments

The impact of GCN and multi-layer attention mechanism for multi-relation encoding

Relationship encoding employs a blend of GCN and multi-layer attention mechanism. This Ablation experiment is conducted on the FB15k-237 and NELL-995 datasets. “D,” “R,” and “T” represent the DistMult, RotatE, and TransE decoders, respectively. “1” signifies the exclusion of GCN, while “2” denotes the absence of multi-layer attention mechanism. For instance, “w/oJG-D1” denotes the JGURD-DistMult without GCN with all other settings identical to those of JGURD-DistMult, while “w/oJG-T2” indicates the JGURD-TransE without multi-layer attention mechanism with all other settings identical to those of JGURD-TransE.

As shown in Fig. 9, removing either GCN or multi-layer attention mechanism from the JGURD results in a certain degree of performance degradation. Compared to GCN, multi-layer attention mechanism has a more significant impact on performance. It’s because omitting the multi-layer attention mechanism would hinder JGURD’s ability to capture the global structure among relationship nodes in the RCG. Especially in multi-relational graph completion tasks, global information’s absence results in more significant performance degradation.

Impact of dropout rate

JGURD adds dropout for each layer in GCN and multi-layer attention mechanism. In this subsection, JGURD-RotatE with different dropout rates are conducted on four datasets to analyze the impact of dropout. Here, dropout rate is set as 0, 0.1, 0.3, 0.5, 0.7 and 0.8, respectively. Note that dropout is employed only in the training phase. It should be disabled in testing phase.

Figure 10 illustrates that performance of JGURD-RotatE improves steadily with dropout rates below 0.3, peaking at a dropout of 0.3. Subsequently, performance begins to decline as the dropout rate surpasses 0.3. This suggests that employing moderate dropout can attain a balanced regularization effect, effectively mitigating overfitting and enhancing generalization ability.

Impact of relation directions

To explore the impact of the incoming and outgoing directions of relationships on KGC performance during entity encoding and joint gradient updates, this section presents two variants of JGURD and evaluates them on three multi-relation datasets: FB15k, FB15k-237, and NELL-995.

Variant A: In entity encoding and joint gradient updates the directions of relationships are ignored. Specifically entity encoding does not include relationship direction embeddings and only the randomly initialized entity embedding $e_u$ is used for graph convolution. During joint gradient updates the entity’s neighbor set is not differentiated by relationship direction.

Variant B: The incoming and outgoing directions of relationships are considered only during entity encoding, not during joint gradient updates.

The results are shown in Fig. 11, where D, R, and T denote JGURD-DistMult, JGURD-RotatE, and JGURD-TransE, respectively, and variant A and variant B are two variants of JGURD. It can be seen from the figure that considering the incoming and outgoing directions of relationships during entity encoding and joint gradient updates significantly affects KGC performance. Specifically, the MRR and Hits@10 of Variant A are lower than those of the original model across all datasets, indicating that completely ignoring relationship directions hinders the model’s ability to fully leverage the structural information in KGs, thereby impacting completion performance. Variant B performs better than Variant A but worse than the original model, indicating that considering relationship directions during entity encoding improves model performance to some extent. However, ignoring relationship directions during joint gradient updates still prevents the model from achieving optimal performance. This further emphasizes that relationship direction is a critical factor in KGC.