2.1 Approaches Relying on Translation

By encoding things into low-dimensional embeddings and the relationships between them as translation vectors, translation-based algorithms provide great performance with low complexity in knowledge graph of artificial intelligence of social things. To determine whether a triplet is accurate, these methods usually use distance-based scoring and establish a translation scoring system based on dependencies. As the foundation of translation models, the TransE model [13] can outperform most conventional methods while maintaining a reasonable level of efficiency by translating entities and their relationships into a continuous low-dimensional vector space. In this space, the tail entity is thought of as the product of translating the head entity by the relationship vector. Nevertheless, when it comes to modeling complicated relationships, the TransE model falls short due to its oversimplification, which restricts it to 1-to-1 relationships. One example is the TransH model [14], which uses an extra mapping vector for every relationship. This allows it to translate things by assigning them to hyperplanes of the relationship. Convolutional neural networks (CNNs) are used to build the discriminator because of their great performance in semantic feature extraction. This helps to improve the semantic distinction between the expert paths and the generated paths. Semantic feature extraction is carried out after the generated paths and expert paths are packaged as path bundles for every entity pair. The PKICLA model determines the probability score for the validity of the candidate triplets by extracting semantic features from several routes using CNN and Bi-LSTM. By first building entity and relationship embeddings in their own vector spaces, the TransR model [15] can then translate these into their respective relationship spaces. To improve computational performance, the TransD model [16] replaces matrix multiplication with vector multiplication, embeds two vectors for each entity, and assigns a new relationship mapping matrix to each entity, all of which are advancements over TransR. In general, approaches based on translation, which depend on internal structural information, are straightforward, efficient, and frequently utilized as a base for expanding models. These methods are employed to solve knowledge graph completion challenges.

2.2 Techniques Reinforced by Semantic Matching

The conventional approach to knowledge prediction using semantic matching involves calculating a scoring function that estimates the probability of new facts emerging from existing data by measuring the possible semantic similarity of entities and relationships in vector space. Binary relationship data is intrinsically structured, as the RESCAL model [17] illustrates via a third-order tensor decomposition. An entity’s possible semantics are represented by a vector, and the interactions between these vectors are simulated using a relation matrix. By substituting a diagonal matrix for the dense one in RESCAL, the DistMult model drastically lowers the model’s computing parameters. While the DistMult model is capable of handling asymmetric relations in the knowledge graph, this is because the product operator on real numbers has the property of being balanced. Recognized as the pioneer in handling symmetric and antisymmetric relations using complex-valued embeddings in complex space, the ComplEx model [18] represents each embedding with two vectors, one for real and one for imaginary components. When it comes to representing entities and relationships, traditional semantic matching-based models have limitations due to their exclusive focus on the intrinsic feature information of the triplet and their disregard of the rich According to research on semantic matching approaches, neural networks can accurately model the semantic links between individual items and intelligently capture their semantic properties, which in turn improves the reasoning accuracy of the model. A two-dimensional convolutional network is employed by the ConvE model [19] to anticipate new information in the knowledge graph of artificial intelligence of social things by combining local spatial aspects of entities and relationships from various viewpoints. The main difference between ConvE and the ConvKB model [20], which was presented later, is that the latter employs a 1D convolutional network to extract global associations along the same dimension of the input triplet matrix, rather than a 2D one. This allows ConvKB to represent each triplet as a 3D matrix. To characterize the possible semantic linkages along routes of any length, the PATH-RNN model [21] applies composite functions recursively using a recurrent neural network., generating corresponding path vectors to infer missing relations in the knowledge graph of artificial intelligence of social things. The Single-Model model, based on PATH-RNN, combines relationships, entities, and entity types to effectively improve the model’s reasoning performance.

2.3 Relationship Path-Based Methods

In knowledge graphs, there are many relationship paths between entity pairs that represent their semantic relationships. One reason knowledge graph completion has progressed is because relationship path-based methods have become more popular; these pathways reflect the intricate reasoning patterns between relations in the knowledge graph of artificial intelligence of social things. Learning relationship paths for reasoning in knowledge graphs were initially introduced by the PRA model. It takes a pair of entities as input, uses a classifier to find out if the relationship you’re asking about actually exists, and then builds relationship pathways between them using random walks. By including multi-path relationship reasoning and utilizing a resource allocation technique to apply weights to the many routes, the PTransE model improves the efficiency of the translation-based model’s predictions. In contrast to the PRA algorithm’s random walk technique, the DeepPath model searches for reasoning paths in the knowledge graph using reinforcement learning, enabling it to regulate the nature of the search. The MINERVA model [22] is very similar to DeepPath in that it uses LSTM networks to define relationship paths and uses path validity as the only measure of success for rewards. By encoding the historical information of the searched paths in an RNN and mapping it into the reinforcement learning state and action space, the M-Walk model [23] improves reasoning accuracy through inferring paths and generating more positive rewards through an improved Monte Carlo Tree Search (MCTS). The DIVINE model can adaptively adjust the reward function to optimize model performance based on different environments. These models only consider single-path reasoning and ignore the semantic similarity between multiple paths. Given the scenario described above, an emergent entity’s current neighbors are taken into consideration as an additional kind of input for inductive models. Hamaguchi et al. [24] suggest using a Graph Neural Network (GNN) on the KG, which creates an embedding of a new item by combining all of its neighbors that are known to exist. Hao et al. [25] the neighbors’ differences are ignored by their model, which aggregates them using basic pooling techniques.

The APCM model [26] introduces an attention mechanism into relationship paths, assigning different weights to each generated path based on its importance by comparing the semantic similarity between each path and the candidate relationship. The PKICLA model uses CNN and Bi-LSTM to extract semantic features of multiple paths and calculates the probability score for the validity of the candidate triplets.

3.1 Reasoning Engine

In the RPEN-KGC model, the reasoning engine consists of a generator and a discriminator. The generator performs random walks in the knowledge graph to generate many relationship paths. These paths are then input, along with the expert paths generated by the sampler, into the discriminator. The discriminator evaluates the semantic similarity between the generated paths and the expert paths as reasoning evidence, providing feedback to the generator for parameter adjustment. Once the discriminator and generator have undergone enough adversarial training, reliable paths that match the expert path distribution can be found, which can then be used for knowledge graph of artificial intelligence of social things completion.

Figure 1 Overall framework of the RPEN-KGC model.

To find reliable paths that match the expert paths in the semantic space, the generator is constructed using a policy-based agent in reinforcement learning. Since convolutional neural networks (CNNs) have high performance in semantic feature extraction, the discriminator is constructed using a CNN, which helps better distinguish between the generated paths and the expert paths semantically. The generated paths and expert paths are packaged for each entity pair in the form of path bundles, and semantic feature extraction is performed. Figure 2 provides a basic schematic diagram of the path bundle embedding representation.

Figure 2 Schematic diagram of path bag embedding representation.

The path $q=\{r_1,r_2,\cdots ,r_k,\cdots \}$ is embedded as:

Each path is composed of k relations, and each relation is embedded using the TransE method, mapping it into a vector $r_k\in {ℝ}^d$.

Each path bundle t contains N paths. By embedding and concatenating all paths in the bundle, a real-valued matrix is obtained.

where, $\oplus$ represents the concatenation operator for the path bundle $t\in {ℝ}^{Nd}$.

After encoding the path bundle, it is input into a discriminator based on a convolutional neural network to extract its semantic features. First, local features are extracted through a convolutional layer activated by ReLU non-linear activation.

where, $\omega \in {ℝ}^{h\times l}$ is the convolution kernel, and $b_f$ is the bias coefficient.

Then, semantic features are further extracted through two fully connected layers:

For simplicity, the corresponding bias terms are omitted in the equations. ${𝐙}_1$ and ${𝐙}_2$ represent the linear transformation matrices of two different fully connected layers. The output of Equation (4) is normalized using the sigmoid function, while other layers employ the ReLU function for non-linear transformation.

The probability of generating a path as an expert path is calculated using the sigmoid function, and the knowledge graph of artificial intelligence of social things is completed based on the probability results.

3.2 Sampler

Local Relation Sampling: The knowledge graph uses a bidirectional breadth-first search strategy to discover the shortest path between each entity pair. The correlations between entity pairs are more directly reflected in shorter paths. Although longer paths may hold hidden value, they are more likely to introduce noise, which can reduce the quality of expert paths. By performing local relation sampling for each entity pair, an initial expert path set $\Omega$E is obtained.

Global Relation Sampling: Static sampling techniques are easy to use, but they produce fewer expert paths and ignore each entity’s local context in the artificial intelligence of social objects knowledge network. As a result, this research suggests a sampling strategy based on entity neighborhood similarity. For each query triple, the method extracts its relation r and the entity pairs directly connected to it in the knowledge graph as the sampling set. Using the distribution characteristics of word vectors in the semantic space (i.e., the more similar the attribute information or descriptions of entities, the closer they are in the embedding space), the similarity between the entity pairs in the given triple and those in the sampling set is measured via vector dot product. A higher result indicates greater similarity between the entities. To better transfer relation $r$ to other entity pairs, entity pairs with high similarity scores for both head and tail entities are selected for subsequent path exploration.

For the relation $r_i\in R$ in a given triple, all entities $e$ connected to $r_i$ form the set $E_j$, and the tail entities among them form the set $U_j$. In the knowledge graph of artificial intelligence of social things, through random walk, if any entity $h_j$ in the set $E_j$ reaches $u_j\in U_j$ after several steps, the path is recorded as $\tau$, and all $\tau$ obtained from the relationship $r_i$ are taken as its characteristic path set ${\Gamma }_{r_i}$. $\left|{\Gamma }_{r_i}\right|$ represents the number of characteristic paths in ${\Gamma }_{r_i}$. After the path exploration is completed, the symbol ${\tau }_j\in {\Gamma }_{r_i}\left(j=1,2,\cdots ,\left|{\Gamma }_{r_i}\right|\right)$ represents the $j$ characteristic path obtained by the relationship $r_i$. In order to ensure the quality of the expert path, the number of random walk steps is set to 3. The possibility of the head entity $h_j$ reaching $u_j$ through each path ${\tau }_j$ is:

where, ${\tau }_j^{\prime }$ is the sub-part of the path ${\tau }_j$ without the tail relation $r_i^{\prime }$, and $Q\left(u|e;r_i^{\prime }\right)$ represents the probability that $e$ reaches $u$ through the relation:

where, $d\left(E_j^c\cdot e\right)$ represents the degree of association between entities obtained through cosine similarity and is used in the result calculation. Cosine similarity is used to determine the degree of link between items, and this information is used to calculate the result. The dynamic sampling model’s parameters are trained in this study using a logistic regression approach, which also maps the computation. Using the sampler and generator, sampling and learning are carried out for every entity pair throughout the training phase. Some baseline models find this difficult, requiring manual hyperparameter modifications to fit various datasets. Creating appropriate hyperparameters by hand might be challenging. This paper employs a logistic regression algorithm to train the parameters of the dynamic sampling model and maps the computation results to the range $(\mathrm{𝟎},\mathrm{𝟏}]$ using the sigmoid function.

where, $Y$ represents the probability of successfully transferring the relation $r_i$ from a given triple to other entity pairs. A higher $Y$ value indicates a greater likelihood of successful transfer.

3.3 Training

During the training phase, for each entity pair, sampling and learning are performed using the sampler and generator. Based on whether the agent can reach the target entity along the currently collected paths, corresponding expert path sets ${\Omega }_E$ and generated path sets ${\Omega }_{G0}$ are created. The collected paths are then grouped into different path bundles: expert path bundles $\left\{u_e\right|u_e\subseteq {\Omega }_E\}$ and generated path bundles $\left\{u_g\right|u_g\subseteq {\Omega }_G\}$.

For each path bundle pair $⟨u_e,u_g⟩$, the discriminator aims to clearly distinguish between $u_e$ and $u_g$. To make the adversarial training process more stable and effective, the RPEN-KGC model updates the discriminator using the loss function proposed in the WGAN-GP model.

where $A_C,A_P$, and $A_D$ represent the critic function, gradient penalty function, and discriminator loss function, respectively. $\lambda$ is the gradient penalty coefficient, and $\tilde{u}$ is uniformly sampled between $u_g$ and $u_e$. Based on the feedback from the discriminator, the reward ${\Re }_G$ is calculated as:

where, $u_n$ represents noise embeddings composed of continuous uniformly distributed random noise, $H_g$ denotes the characteristic function indicating the validity of the bundle $u_g$, and ${\Omega }_G^{+}$ represents the set of all valid generated paths. By rewarding valid paths with higher expectations compared to noise embedding $u_n$, poor-quality paths are filtered out, improving the efficiency of convergence during training.

Finally, the loss function of the discriminator is optimized using the mini-batch stochastic gradient descent algorithm, while the generator is updated using the Adam algorithm [27].

4.1 Databases and Assessment Criteria

In this study, two commonly used datasets for knowledge graph of artificial intelligence of social things completion experiments: NELL-995 [28] and FB15K-237 [29], for link prediction. Detailed information is shown in Table 1. The link prediction task’s NELL-995 and FB15K-237 datasets demonstrate that RPEN-KGC significantly outperforms baseline methods in the majority of metrics. These results demonstrate that RPEN-KGC is capable to accurately predicting knowledge graphs’ missing data.

To evaluate the performance of the model, this study adopts commonly used metrics in the task of knowledge graph completion: MAP (mean average precision), MRR (mean reciprocal rank), and Hits@k.

In this case, the ranks of positive samples are represented by $\text{rank}\left(y\right)$ while those of negative samples are represented by $\text{rank}\left(y\right)$. Here, $u_i$ stands for the test set and $m$ for the overall sample size.

4.2 Comparison Methods and Parameter Settings

The model is tested against multiple baseline models to ensure its efficacy:

In the experiments, every path bundle $u$ has N=5 paths, and the embedding dimension is set at 200. In this convolutional neural network, the parameters 3×N for the convolution kernel, $\lambda$ for the gradient penalty, 1024 for the hidden layer, and a size for the output layer that corresponds to the path embedding dimension are all set. L2 regularization is used to avoid overfitting.

During testing, invalid triples are scored alongside valid triples at a ratio of approximately 1:10, with invalid triples generated by randomly replacing entities.

4.3 Results and Analysis

Table 2 displays the link prediction experiment outcomes in comparison to baseline models. Compared to NELL-995, RPEN-KGC performs better than the majority of baseline models, especially on larger datasets like FB15K-237, which has a more complex distribution of relation types. Specifically:

Comparison Insights:

On FB15K-237, RPEN-KGC consistently achieves the best performance across all evaluation metrics. This is due to two key reasons:

As a result, RPEN-KGC demonstrates more stable performance and better real-world applicability compared to other models.

Relationship paths and entity neighbourhood data are combined for knowledge graph fused using a novel method called RPEN-KGC (Relationship Path and Entity Neighbourhood Knowledge Graph Completion). The sampler provides the inferencer with reliable inference methods by randomly walking between entity pairs. To increase sampling efficiency and support inference methodologies, the sampler steers random walks using a contrastive method based on entity neighborhood similarity. The inferencer infers a wider range of relationship paths within the semantic domain and extracts semantic properties of relationship paths. RPEN-KGC greatly improves most metrics compared to baseline methods, according to experiments conducted on the publicly available NELL-995 and FB15K-237 datasets for the link prediction task. These results show that RPEN-KGC effectively predicts knowledge graphs with missing information.

4.4 Ablation Study

To validate the effectiveness of the model’s components, an ablation study was conducted by removing certain components of the model and retraining on the FB15K-237 and NELL-995 datasets. This quantifies the contributions of each component. The three model variants in this study are as follows:

On the NELL-995 and FB15K-237 datasets, the MAP metric is used to evaluate the link prediction performance of the model. The experimental results are shown in Table 3.

After removing the local relation sampling module, global relation sampling module, and sampler module, the MAP metric of the model shows varying degrees of decline.

The ablation study results demonstrate the rationality of each component in RPEN-KGC.

In order to develop reasoning paths for the completion task and hence increase the model’s robustness to noisy data, the RPEN-KGC model employs a generator-adversarial network-based reasoning engine to train adversarial on the generated samples and expert samples created by random walks.