Deep Model-Based Security-Aware Entity Alignment Method for Edge-Specific Knowledge Graphs

Abstract

This paper proposes a deep model-based entity alignment method for the edge-specific knowledge graphs (KGs) to resolve the semantic heterogeneity between the edge systems’ data. To do so, this paper first analyzes the edge-specific knowledge graphs (KGs) to find unique characteristics. The deep model-based entity alignment method is developed based on their unique characteristics. The proposed method performs the entity alignment using a graph which is not topological but data-centric, to reflect the characteristics of the edge-specific KGs, which are mainly composed of the instance entities rather than the conceptual entities. In addition, two deep models, namely BERT (bidirectional encoder representations from transformers) for the concept entities and GAN (generative adversarial networks) for the instance entities, are applied to model learning. By utilizing the deep models, neural network models that humans cannot interpret, it is possible to secure data on the edge systems. The two learning models trained separately are integrated using a graph-based deep learning model GCN (graph convolution network). Finally, the integrated deep model is utilized to align the entities in the edge-specific KGs. To demonstrate the superiority of the proposed method, we perform the experiment and evaluation compared to the state-of-the-art entity alignment methods with the two experimental datasets from DBpedia, YAGO, and wikidata. In the evaluation metrics of Hits@k, mean rank (MR), and mean reciprocal rank (MRR), the proposed method shows the best predictive and generalization performance for the KG entity alignment.

1. Introduction

As edge computing becomes more prevalent, the collaboration and collaboration between the multiple edge systems (ESs) required to perform a specific task (e.g., service delivery, data privacy, and security) become important [1,2,3]. At this time, for the ESs to collaborate and cooperate seamlessly, the heterogeneity of the data they must share, particularly the semantic heterogeneity, must be addressed [4,5]. Until recently, the ontology, which was domain-specific and had a rigid structure, was the primary method for solving the semantic heterogeneity of the data in the ESs [6,7]. However, due to the easy and frequent change of the components of the ESs, their operating environments can be very dynamic [8]. In addition, collaboration between heterogeneous ESs for multiple domains is absolutely required to perform some tasks [9]. It is very difficult to accommodate these changes in the ontology with their security and privacy policies. Thus, it is a non-trivial task to develop an ontology that encompasses such diverse domains for the dynamic and collaborative edge computing.

To overcome the limitations of the ontology, attention is given to solving the semantic heterogeneity of the data of the ESs with a knowledge graph (KG) that can structurally represent human knowledge using entities, relations, and semantic descriptions [10]. By simply adding some entities and their relationships related to the changed environments to the KG, it can rapidly and easily reflect dynamic changes of the ESs. Furthermore, it can develop diverse domain knowledge models that are not limited to a specific domain [11]. At present, as an early stage of applying the KG, researchers are using edge-specific KGs to resolve the semantic heterogeneity of the internal data necessary to ensure the security and privacy of the ESs [12]. However, as cooperation and collaboration between the ESs become common, they will require a new method of using the edge-specific KGs that can resolve the semantic heterogeneity of data required for their cooperation and collaboration while maintaining the security and data privacy of each ES. To propose the new method, we researched as follows.

First, we explore the unique characteristics of the edge-specific KGs. To resolve the semantic heterogeneity of data used in the multiple heterogeneous ESs, the relations between them, especially the equivalence relation, must be clearly identified. Fortunately, entity alignment, which is identified as the equivalence relation between entities in different KGs, has already been proposed [13]. Unfortunately, the KGs used in the entity alignment are the general-purpose KGs, such as DBpedia and YAGO, with different properties to the edge-specific KGs [14]. So, before proposing an entity alignment method suitable for the edge-specific KGs, we conducted research to find the unique characteristics of the edge-specific KGs.

Second, based on the unique characteristics of the edge-specific KGs, we propose a novel entity alignment method for the edge-specific KGs, named the deep model-based security-aware entity alignment method. The properties of the proposed method are as follows. The deep model is used for learning the semantic relations between the concept and instance entities that are the target of the entity alignment. At this time, two deep models, named BERT (bidirectional encoder representations from transformers) [15] for the concept entities and GAN (generative adversarial networks) [16] for the instance entities are applied to train for each because the properties of the concept and the instance entities are very different. In particular, for the security and privacy of the ES data, the data must not be exposed outside the ESs during the entity alignment process. To do so, we utilize the deep models, neural network models that humans cannot interpret. This is because these neural network models can perform the entity alignment considering the security and privacy of the ES data by hiding the model’s input data and hyperparameters.

Third, this paper proposes a graph-based deep learning model that can integrate the learning models for the BERT for the concept entities and the GAN for the instance entities. Although the deep model learning for the entity alignment was separately performed considering the characteristics of the concept and the instance entities, information sharing between them is required to perform the entity alignment robustly because the instance entities as well as the concept entities may be used to describe the concept entities. Conversely, the concept entities, as well as the instance entities, may be used to describe the instance entities. A flexible graph-based deep learning model named GCN (graph convolution network) is utilized to integrate two deep models trained on two types of entities with different characteristics [17]. So, this paper attempts to merge the learned models for concept and instance entities into one deep model by borrowing graph-based deep learning models and transfer learning approaches.

This paper is organized as follows. In Section 2, we describe the characteristics of the general-purpose KG and the edge-specific KG. Section 3 represents the overall architecture of the deep model-based security-aware entity alignment framework and the detailed process of each module. In Section 4, we conduct the experiments to show the superiority of the proposed methods for KG entity alignment in comparison with the comparative methods. The related studies on the KGs in edge computing and KG entity alignment are summarized in Section 5. Finally, Section 6 puts forth the conclusions and suggests further research on the KG entity alignment framework in edge computing and takes security into consideration.

2. General-Purpose KG vs. Edge-Specific KG

As mentioned earlier, the entity alignment method has already been proposed to increase the utilization of the KGs [18]. Currently, conventional entity alignment is performed using the following characteristics of the KGs. In many applications, the KGs are used as the graph-structured knowledge bases (KBs) that can structurally represent human knowledge using entities, relations, and semantic descriptions [10]. Many KGs, including YAGO, DBpedia, and the Google Knowledge Graph, have already been developed and used [19]. These KGs are the general-purpose KGs that include comprehensive and multidisciplinary knowledge. Therefore, they have following properties. First, the general-purpose KGs are created mainly for concept entities with higher levels of abstraction than instance entities with lower levels of abstraction because they represent knowledge across multiple domains. Currently, when using the general-purpose KG, regardless of the domains, it describes in detail the description of the concept entities themselves, their relations to other concept entities (e.g., taxonomic relations), and their literal and textual descriptions. Second, the general-purpose KGs contain multidisciplinary information and are large-scale [20,21]. Therefore, it is highly likely that the entities to be aligned and their information, such as their taxonomic relations and their literal and textual descriptions, will be included in several general-purpose KGs. Multiple general-purpose KGs may contain the same concept and instance entities simultaneously. Of course, depending on the development intention of the general-purpose KGs, the concept and instance entities may or may not be represented in a similar structure. Third, the general-purpose KGs emerged to increase the utilization of information by sharing and disclosing all information, such as the concepts and instances, to users through the connection of multidisciplinary information. In other words, their degree of information openness is very high.

As the goal of this paper is to propose the entity alignment method for the edge-specific KGs, we analyze the properties of the edge-specific KGs in terms of the level of abstraction, the degree of data overlap, and the information openness, which are the properties of the general-purpose KGs. The first is the level of abstraction. Unlike the general-purpose KGs, which are developed to perform domain-independent operations, the edge-specific KGs are created to support only the functions of the corresponding ESs [22]. Furthermore, the primary function of the edge-specific KGs is to solve the heterogeneity of the data collected by the sensing devices of the edges; so, they are composed mainly of the instance entities rather than the concept entities. Contrary to the concept entities, as most instance entities are leaf nodes of the KGs they lack taxonomic relations, literals, and textual descriptions. The second is the degree of overlapped data. As the edge-specific KG contains only information related to the specific ESs, the scale is small, and the information contents are very specific. Therefore, the possibility that the edge-specific KGs contain the overlapped information necessary for the entity alignment is very low. The third is the difference in the degree of information openness. The edge-specific KGs disclose some concepts inherited from the general-purpose KGs but suppress external exposure by modeling the users’ private information or the sensory data of the ESs, to be protected as their instances. Therefore, their degree of information openness is very low. In this light, the conventional entity alignment methods, which are conducted using the characteristics of the general-purpose KGs, cannot apply the alignment of the edge-specific KGs. So, this paper proposes a novel entity alignment method specialized in the edge-specific KGs. The comparison results are summarized in

Table 1. Comparison of general-purpose KG and edge-specific KGs.

	General-Purpose KG	Edge-Specific KG
Level of abstraction	High	Low
Degree of data overlap	High	Low
Degree of information openness	High	Low

.

Based on the above analysis, we discovered the characteristics that the entity alignment method of the edge-specific KGs should have; these are as follows.

First, the characteristics of the edge-specific KGs, which are mainly composed of the instance entities rather than the conceptual entities, should be reflected. For this, rather than the entity alignment using the graph topological similarity of the entities, the entity alignment method using data characteristics should be devised. To do so, the proposed method performs two-way entity alignment for the concept and instance entities using different data-centered deep models.

Second, the concept entities have rich information, such as taxonomic relations, literals, and textual descriptions, but with a very small amount of overlapped information needing to be aligned. Therefore, it is tough to align them only with the information of the concept entities contained in the edge-specific KGs. To reduce the difficulty, this paper attempts to expand the range of information available into external information, such as general-purpose KGs and web documents.

Third, for the security and privacy of the instance entities in the edge-specific KGs, the sensing data should not be exposed to the outside during the alignment process. In this light, this paper uses the GAN, which is a neural network model that humans cannot interpret because it is a black-box model. As a result, it is possible to perform alignment considering the security and privacy of the instance entities by hiding the input data and the hyperparameters of the model. In Section 3, we delve into the entity alignment method of the edge-specific KGs in detail.

3. Overall Framework

Based on the characteristics that the entity alignment method of the edge-specific KGs should have, this paper proposes a novel alignment method. The proposed method is conducted in three phases. The first phase identifies the entities from each edge-specific KG into the conceptual and instance entities. To do so, we perform graph clustering utilizing the graph properties of the edge-specific KGs. The second phase, which is the core of the proposed method, performs the learning to align the concept and instance entities. At this time, considering the properties of the concept and instance entities, the former uses a language model, and the latter uses a GAN model to perform learning. Finally, by merging the two learned models, an alignment model for the edge-specific KGs is generated. The overall framework of the proposed method is depicted in Figure 1.

This section may be divided by subheadings. It should provide a concise and precise description of the experimental results, their interpretation, as well as the experimental conclusions that can be drawn.

3.1. Graph Clustering-Based Concept and Instance Entities Identification

The concept and instance entities are mixed in the general-purpose KG as it is a large dataset that contains sufficient information for entity alignment. There is no problem in performing the entity alignment without a distinction between the concept and the instance entities in the general-purpose KG. On the other hand, for the edge-specific KGs constructed for the specific purposes, the volume of the dataset is significantly smaller than that of the general-purpose KGs. It makes it difficult to learn relationships between entities for the predictive model, which significantly reduces the performance of the entity alignment. To improve the performance, we first distinguish the concept and instance entities from the edge-specific KGs.

To identify the concept and instance entities from the edge-specific KGs, we first explored the structural characteristics of the concept and instance entities in the edge-specific KGs. From the point of view of the graph’s structure, the concept entities have many links and have greater outdegree than indegree because they are used to explain other concepts and instances in the edge-specific KGs. In contrast, instance entities have fewer links and have greater indegree than outdegree because they are the physical objects that reify the concept entities [23]. Using these structural characteristics, we will identify the concept and instance entities in the edge-specific KGs. Centrality is a representative metric that uses the graph’s structure, especially the number of connections with other nodes, to find important nodes included in the graph. The more connections a node has, the more important it is. In other words, a node with a large centrality is an important node. Let us project these centrality properties onto the identification of conceptual and instance entities. So, an entity with a large centrality value, that is, an entity with an outdegree greater than the indegree, becomes a concept entity. In contrast, an entity with a small value, that is, an entity with an outdegree smaller than the indegree, becomes an instance entity.

There are three types of centrality metrics used in the structural analysis of graphs: degree, closeness, and betweenness [24,25]. Degree centrality can determine which entities have the most links. It is calculated based on the number of relations between two arbitrary entities in the edge-specific KGs [26]. However, as it only considers one-hop neighbors, it is difficult to capture the structural difference between the concepts and the instances. To reduce the difficulty, we simultaneously use betweenness centrality and closeness centrality, which can reflect the different aspects of multi-hop neighbor structures. The betweenness centrality is based on the paths of two arbitrary entities, which reflects the density of the path, while the closeness centrality is based on their distances, which reflects the length of the paths. So, we use all three centrality indices simultaneously to capture the structural information of the KGs from multiple perspectives.

The centrality indices we use are represented as follows, respectively.

$$dc\left(e_x\right)=\lambda ·log\left(1+\frac{{deg}^{+}\left(e_x\right)}{{deg}^{-}\left(e_x\right)}\right)$$

(1)

$$bc\left(e_x\right)={\displaystyle \sum }_{x\ne y\ne z\in G}\frac{{\sigma }_{yz}\left(e_x\right)}{{\sigma }_{yz}}$$

(2)

$$cc\left(e_x\right)=\frac{1}{{{\displaystyle \sum }}_{x\ne y\in G}d\left(e_x,e_y\right)}$$

(3)

where $dc\left(e_x\right)$, $bc\left(e_x\right),$ and $c\left(e_x\right)$ are degree centrality, betweenness centrality, and closeness centrality of entity $e_x$, respectively. ${deg}^{+}\left(e_x\right)$ and ${deg}^{-}\left(e_x\right)$ are the outdegree and indegree of $e_x$, respectively. $\lambda$ is the scale coefficient. In addition, ${\sigma }_{yz}$ is total number of shortest paths from $e_y$ to $e_z$, and ${\sigma }_{yz}\left(e_x\right)$ is the number of those paths that pass through $e_x$, and $d\left(e_x,e_y\right)$ is the distance two arbitrary entities $e_x$ and $e_y$ $\left(e_x,e_y,e_z\in KG,x\ne \mathrm{y}\ne \mathrm{z}\right)$.

Using calculated centrality values, we perform spectral clustering with the number of clusters $k=2$, showing the best performance for the data where the dimensionality reduction is essential, such as the edge-specific KGs. Based on the centrality values, the Euclidean distance between two arbitrary entities $e_x$ and $e_y$ ($d\left(e_x,e_y\right)$) is calculated as follows.

$$\left(e_x,e_y\right)=\sqrt{{\left(dc\left(e_x\right)-dc\left(e_y\right)\right)}^2+{\left(bc\left(e_x\right)-bc\left(e_y\right)\right)}^2+{\left(cc\left(e_x\right)-cc\left(e_y\right)\right)}^2}$$

(4)

By using the distances between the entities, the affinity matrix of the edge-specific KG ($W$) is calculated. The affinity value $w_{ij}$ for $e_i$ and $e_j$ in $W$ is calculated as follows.

$$w_{ij}=\exp \left(-\frac{d\left(e_i,e_j\right)}{2{\sigma }^2}\right)$$

(5)

where $d\left(e_i,e_j\right)$ is the distance between $e_i$ and $e_j$. $\sigma$ is the gaussian kernel parameter.

For the two clusters, $C_1$ and $C_2\left(C_1{{\displaystyle \cap }}^{}{C}_2=\varnothing \right),$ which are the result of the spectral clustering, the concept and instance entities are determined. At this time, as a centrality-based distance measure identifies the two clusters, one of the two clusters is a cluster of the entities with a low outdegree compared to the indegree (a.k.a. concept entity), and the other is a cluster of the entities with a high outdegree compared to the indegree (a.k.a. instance entity). The entities that belong to a cluster with a large sum of centrality (smaller) are determined as the concept (instance) entities. Finally, we obtain the concept entities ($c{e}_x$) and instance entities ($i{e}_x$).

3.2. Semantic Relation Learning Module

3.2.1. Language Model-Based Learning for the Concept Entities

As mentioned earlier, the concept entities have rich information, such as taxonomic relations, literals, and textual descriptions, but with a very small amount of overlapped information needing to be aligned. To address the lack of overlapped information, this paper proposes a method to learn the equivalence relations between the concept entities using not only KGs but also pre-trained language models and external sources. At this time, the pre-trained language models and external sources are used to resolve the lack of overlapped information by learning the generalized lexical relationships between two concept entities, predicting equivalence relations, and generating additional overlapped information. The language model-based learning is composed of three steps, which are depicted in Figure 2.

• Step 1 Data Collection

To train the pre-trained language model, enough input data must be secured. However, the data we currently have available are the concept and instance entities identified by the edge-specific KGs. As there are very few concept entities in the edge-specific KGs, it is impossible to train a language model with this alone. To amplify the number of concept entities, we extract the partial graphs related to the concept entities from the general-purpose KGs that inherit some of the concept and instance entities to the edge-specific KGs. However, there are still insufficient data to train a language model with only the concept entities in the general-purpose KGs as they contain only information with a graph structure for the concept entities. To compensate for the lack of training data, we randomly sample vocabulary documents similar to the concept entities from external sources such as web documents. The general-purpose KGs, the concept-related partial graphs, and the web documents are defined as follows.

Definition 1.

General-purpose knowledge graph($K{G}_{gp}$). $K{G}_{gp}$ is an overarching KG that contains a wide variety of domains and their information, which consist of entities, literals, and relations. It can be represented as a set of subject–property–object triples, depicted as follows.

$$K{G}_{gp}=\left\{\left(s_i, p_i, o_i\right)\right| s_i,\in E_{gp}, p_i\in R_{gp}, o_i\in E_{gp}{{\displaystyle \cup }}^{}{L}_{gp}\}$$

(6)

where $s_i$ represents the subject, $p_i$ represents the property, $o_i$ represents the object, $E_{gp}$ represents the set of entities, $R_{gp}$ represents the set of relations, and $L_{gp}$ represents the set of literals contained in $K{G}_{gp}$.

Definition 2.

Concept-related partial KGs ($pK{G}_x$).  $pK{G}_x$ is a partial graph of the $K{G}_{gp}$, which is directly connected to a concept entity ($c{e}_x$).

$$pK{G}_x=\left\{\left(s_x,p_x,o_x\right)|\left(s_x,o_x\right)\in \left\{c{e}_x|\forall x\right\}, \left(s_x,p_x,o_x\right)\subset K{G}_{gp}\right\}$$

(7)

where $c{e}_x$ is an identified entity as a concept entity.

Definition 3.

Sample document ($D_d$).  $D_d$ is the $d^{th}$ sample document including any concept entity as a word of the document.

$$D_d=\left\{\dots ,w_{dt},\dots |\left\{c{e}_x|\forall x\right\}{{\displaystyle \cap }}^{}\left\{w_{dt}|\forall t\right\}\rangle 0\right\}$$

(8)

where $w_{dt}$ is $t^{th}$ word of the sample document $D_d$.

• Step 2 LDA-based topic modeling

In this step, only sample documents ($D_d$) and partial KGs ($pK{G}_x$) that are semantically similar to the arbitrary concept entities are associated with the specific $c{e}_x$. To do so, the LDA topic model is utilized to discover abstract topics and their vectors occurring in a collection of documents, $D=\left\{D_d\right|\forall d\}$. The LDA model takes a set of words as input; the partial KGs and sample documents are transformed into a set of words. As it is simple to transform the sample documents to the set of words, only the process of transforming a partial KG into the set of words is described.

To select and transform only the elements related to the concept entity from the $pK{G}_x$ into documents, we utilize ‘owl:sameAs’ or ‘skos:exactMatch’, which indicate that the two URIs are equivalent. To select only the concept entities with the relation ‘owl:sameAs’ or ‘skos:exactMatch’, we randomly select the pairs of concept entities ($PCE$), which have the relation ‘owl:sameAs’ or ‘skos:exactMatch’ from the $pK{G}_x$. The $PCE$ is simply represented as follows.

$$\begin{gathered} PCE=\left\{\left(c{e}_x, c{e}_y\right)\right| rel\left(c{e}_x,c{e}_y\right){=}^{\prime }owl:sameA{s}^{\prime }or{ }^{\prime }skos:exactMatch{ }^{\prime }\}, \\ c{e}_x\ne c{e}_y,\left(c{e}_x, c{e}_y\right)\equiv \left(c{e}_x, c{e}_y\right) \end{gathered}$$

(9)

For all pairs of the $PCE$, we compare the number of hops between the $PCE$ pairs and the $pK{G}_x$ elements. Finally, we generate $pK{G}_x^{\prime }$ using only $pK{G}_x$ elements connected with n hops or less. This element of $pK{G}_x^{\prime }$ is used to create a set of words, that is, documents to be input into the LDA topic model. At this time, the word set of $pK{G}_x^{\prime }$ ($p{D}_x$) is constructed by extracting only the entity names included in $pK{G}_x^{\prime }$ as components. It is simply represented as follows.

$$p{D}_x=\{\dots ,n{\left(E_{gp}^{\prime }\right)}_{xt},\dots |E_{gp}\in pK{G}_x^{\prime },\forall x\}$$

(10)

where $n{\left(E_{gp}^{\prime }\right)}_x$ represents the $t^{th}$ name of the entity $E_{gp}$, which is included in $pK{G}_x^{\prime }$.

Third, using all the sample documents, $D_d$, and the transformed documents, $p{D}_x$ ($\forall x$), the LDA-based topic modelling is performed. At this time, the documents are short texts, such as paragraphs of the research publications or Wikipedia, which are randomly collected from well-structured and refined sources and have enough semantic information.

We derive the topic distribution vectors for each document from $D_d$ and $p{D}_x$ using the LDA-based topic model. The results of the topic modeling are as follows.

$$\begin{gathered} d{\theta }_m=\left\{d{\theta }_{m, 1}, d{\theta }_{m, 2}, \dots , d{\theta }_{m, k}, \dots , d{\theta }_{m, K}\right\} for m=1, 2, \dots , M \\ e{\theta }_{p, n}=\left\{e{\theta }_{p, n, 1}, e{\theta }_{p, n, 2}, \dots , e{\theta }_{p, n, k}, \dots , e{\theta }_{p, n, K}\right\} for n=1, 2, \dots , N \\ and p=1, 2, \dots ,P \end{gathered}$$

(11)

where $K$ is the number of topics, $d{\theta }_m$ represents the topic distribution vector of the document $d_m$ in $pD=\left\{p{D}_x\right|\forall x\}$ and $D_d$, $d{\theta }_{m,k}$ is the probability of the topic $k$ of $d_m$ (${\displaystyle \sum }_{k=1}^{K}d{\theta }_{m,k}=1forallm=1,2,\dots ,M$), and $e{\theta }_{p,n,k}$ is the probability of the topic $k$ of $n{\left(E_{gp}^{\prime }\right)}_{xt}$ (${\displaystyle \sum }_{k=1}^{K}e{\theta }_{p,n,k}=1foralln=1,2,\dots ,Nandp=1,2,\dots ,P$).

However, although both the partial KGs and the sample documents are generated based on the concept entities, it is impossible to directly compare their relations because their sources are different. To solve the problem, using the topic vectors generated from the LDA topic model, the concept entities with the most similar topics to the sample documents are found, and the corresponding documents are attached. The process for finding similar topics is as follows.

To discover the documents related to the concept entity $c{e}_x$ (for $\forall x$), we calculate the topic similarity between the documents $D_d$ and $p{D}_x$ using Hellinger distance, which can derive the similarity between probability distributions. The topic similarity between $e{\theta }_{p,n}$ and $d{\theta }_m$ is calculated as follows.

$$sim\left(e{\theta }_{p, n}, d{\theta }_m\right)=\frac{1}{\sqrt{2}}\sqrt{{\displaystyle {{\displaystyle \sum }}_{k=1}^K}{\left(\sqrt{e{\theta }_{p, n, k}}-\sqrt{d{\theta }_{m, k}}\right)}^2}$$

(12)

Based on this similarity measure, the related document of $D_d$ can be discovered with maximum of $sim\left(e{\theta }_{p,n},d{\theta }_m\right)$ in the document distributions.

• Step 3 Training the Prediction Model for Lexical relationships

In the third step, the lexical relations between two arbitrary concept entities are learned using documents attached as a training dataset. Furthermore, a language model capable of predicting equivalence relations is trained. To create a dataset that can learn the equivalence relation, we utilize the sub-structure of the general-purpose KGs. In the sub-structure, we give the label ‘1’ to pairs of documents attached to concept entities with an equivalence relation, and otherwise, we give the label ‘0′. Finally, the language model is learned using the label-annotated datasets. At this time, the transfer learning is performed using a pre-trained language model such as BERT to improve the learning speed and generalization performance.

To train the prediction model of lexical relation between the entities, we utilize the related documents of the previous model. First, we select two arbitrary entities ( $e_i$ and $e_j$) from $PCE$ with the random selection of one related document ($e{d}_{i,a}$ and $e{d}_{j,b}$) for each entity. At this time, the label is $1$ if the two entities have an equivalence relationship ($\left(e_i,e_j\right)\in PCE$) and $0$ otherwise. Second, the entity name and the related document are concatenated and encoded as vectors using the BERT model [27]. Third, the prediction model is trained by using the encoded vectors of the two entities with their related documents. As the prediction model, we adopt the attention network model that is widely used for classification tasks. The prediction model uses the ReLU function as an activation function, which has the advantages of sparse activation as well as a low computational burden.

3.2.2. GAN-Based Semantic Alignment Learning for Instances

In the conventional entity alignment method, the primary information sources about the instance entities are literal or data properties (called attributes) [28]. Unlike the general-purpose KGs, the edge-specific KGs are likely to contain much larger-scale numerical data, such as sensor data in the instance entities, because the ESs operate on the low-end, directly exchange, and store sensor data. However, even if there is a lot of data about the instance entities, it is tough to access because the data of the ESs requires a very high level of security, such as for the information about a specific space or personal privacy. In addition, due to the characteristics of the ESs, which separately store data in multiple repositories, it is also challenging to gather the data required for the entity alignment of the instance entities.

To overcome the difficulties, this paper utilizes the generative adversarial networks (GAN)-based unsupervised instance alignment method for the instance entities. The GAN, as a deep model, has a significant advantage in security because it shields data from being directly interpretable. In addition, it shows an excellent performance in predicting and generating insufficient data as a generative model. Based on the properties of the GAN, this paper obtains the GAN model that can predict the entire data pattern after learning the GAN with subsets of data samples. Finally, this paper performs embedding for the instance entity alignment using the predicted data that the GAN model creates. The learning process of the GAN is as follows.

To train the GAN model, we use instance-related data subsets collected from sensors or devices, such as literal, attribute, or signal data. The data subset is defined as follows.

Definition 4.

Data Subset ($X_x$).  $X_x$ is a subset of data samples related to the $x^{th}$ instance of entity $i{e}_x$

$$X_x=\left\{\cdots ,x_{xt},\cdots \right\}, 1\le t\le n$$

(13)

where $x_{xt}$ is $t^{th}$ data value of $X_x$.

At this time, to perform the alignment of two arbitrary $i{e}_x$ and $i{e}_{x^{\prime }}$, it is necessary to know whether the populations of $i{e}_x$ and $i{e}_{x^{\prime }}$ are equal. However, the volumes of $X_x$ and $X_{x^{\prime }}$, which are the data subsets of $i{e}_x$ and $i{e}_{x^{\prime }}$, are tiny because the data in the edge systems are stored distributionally. In addition, for data privacy and security reasons, blocking the external disclosure of the edge systems’ data is a factor that shrinks the volumes of $X_x$ and $X_{x^{\prime }}$. Therefore, it is challenging to infer the similarity of the entire populations of the two entities with only the similarity of the distributions of $X_x$ and $X_{x^{\prime }}$, which are small in scale. This means that accurate alignment between $i{e}_x$ and $i{e}_{x^{\prime }}$ is difficult. To overcome the difficulty, we use the GAN model, which can learn the distribution of the whole populations. At this time, the GAN model uses the data subset $X_x$($for\forall x$) as its input. Finally, using the reconstructed data subsets ${\widehat{X}}_x$ and ${\widehat{X}}_{x^{\prime }}$ derived from the inferred populations, the entity alignment between $i{e}_x$ and $i{e}_{x^{\prime }}$ is conducted. The GAN consists of two parts: the generator G and the discriminator D [29]. The loss function of the discriminator is defined as follows.

$$\underset{G}{\min }\underset{D}{\max }V\left(D,G\right)={\mathbb{E}}_{x\backsim P_{data}\left(X_x\right)}\left[\log D\left(x\right)\right]+{\mathbb{E}}_{z\backsim P_z\left(z\right)}[\log \left(1-D\left(G\left(z\right)\right)\right]$$

(14)

where $P_{data}\left(X_x\right)$ is the real data distribution from $X_x$, $P\left(z\right)$ is a prior distribution on noise vector $z$, D(x) denotes the probability that $x$ comes from the real data, ${\mathbb{E}}_{x\backsim P_{data}\left(X_x\right)}$ is the expectation of $x$ from $P_{data}\left(X_x\right)$, and ${\mathbb{E}}_{z\backsim Pz\left(z\right)}$ is the expectation of the $z$ sample from the noise.

The trained GAN for each instance is used to attain a reconstructed data sample $\widehat{X_x}$. Using the $\widehat{X_x}$, the equivalence relationships between the instances are identified. The GAN-based instance alignment process is depicted in Figure 3. In Figure 3, an embedding layer is added to obtain fixed dimensional vectors for $\widehat{X_x}.$ The simple description of the process of instance alignment using GAN is as follows. All data subsets of the target instance ($i{e}_x,\forall x$) to perform entity alignment are input to the GAN model. The trained GAN is used to reconstruct the data for all instances. Lastly, it estimates the distribution of instances using reconstructed data and real data and performs entity alignment by inputting the estimated distribution ($\widehat{X_x}$) to the embedding layer.

3.3. Graph-Based Merged Deep Model Learning Module

To perform the edge-specific entity alignment, this module creates the robust entity alignment model for the various structures and the lack of information of the edge-specific KGs by sharing and merging the learned deep models. At this time, it is impossible to directly merge the learning results of the concept and instance entities because the learning was performed using two deep models named the language model and the GAN, with completely different properties. To merge the two heterogeneous deep models, an embedding vector is generated using the learning information of the deep models and then projected onto the graph structure. As a next step, this paper uses a GCN (graph convolution network)-based merged deep model that can perform the entity alignment of the edge-specific KGs by learning only the structural relations of the graph.

As the GNN shows high performance in exploiting graph structure information for many entity alignment tasks, we adopt the GCN model to capture the structural information of the concepts and the instances in the KGs. A GCN model consists of multiple GCN layers. In a GCN model, the input of the $l^{th}$ layer is the entity feature matrix, $H^{\left(l\right)}\in {ℝ}^{n\times d^{\left(l\right)}}$, where n is the number of nodes, and $d^{\left(l\right)}$ is the number of features in the $l^{th}$ layer. The output of the $l^{th}$ layer is a new feature matrix $H^{\left(l+1\right)}$. The convolutional computation of $H^{\left(l+1\right)}$ is as follows.

$$H^{\left(l+1\right)}=\sigma \left(A{H}^{\left(l\right)}{W}^{\left(l\right)}\right)$$

(15)

where $A$ is a normalized adjacency matrix with a self-connected input graph, $H^{\left(l\right)}$ is the hidden states, $W^{\left(l\right)}$ is the weight of the lth layer, and $\sigma \left(·\right)$ is a nonlinear activation function.

Two GCN models for the concepts and instance entities are trained independently because the spaces that explain the concepts and instances are different. Moreover, it is easy to find the optimal hyperplane, and the complexity can be lowered by independently learning. The inputs of the GCN models for the concept and instance entities are the two types of embeddings for the concept and instance entities by the language model-based trained model and the GAN-based trained model, respectively. After the training of the two GCN models, we can obtain the embeddings of the structures of the concept and the instance entities as output by training the GCN models. Finally, the two types of embeddings are concatenated to discover their shared spaces, which cannot be identified by the concept or the instance entities alone. The concatenated embeddings are used for the merged model to get merged embeddings for the alignment task. The details of the merged model are depicted in Figure 4.

The space found by deep learning is almost impossible to be explained without the information of the training dataset and the dimensions and hyperparameters of the models. Therefore, our proposed framework can contribute to the security and privacy issue by only predicting the alignment using the merged model, without directly exposing the structures of the KGs.

4. Experiments and Performance Evaluation

In this section, we first explain the experimental setup, including a summary of the experimental datasets and the comparative methods. We then report the experimental results and analysis compared to the other entity alignment methods. We used a processor with Intel(R) Xeon(R) CPU @ 2.30 GHz, a Teslar P100, and 12 GB memory provided by Google Colab Pro.

4.1. Experimental Datasets

In order to evaluate our proposed framework, we used two datasets, DBP-YG 15K and DBP-WD 15K, sampled from DBpedia-YAGO and DBpedia-Wikidata, respectively [30]. The statistical data of the two datasets are listed in

Table 2. Statistical data of DBP-YG 15k and DBP-WD 15k.

Datasets		#Entities	#Attrs	#Attr. Triples	#Rels	#Rel. Triples
DBP-YG 15k	DBpedia	15,000	39,520	52,093	17,368	30,291
	YAGO	15,000	117,622	117,114	15,859	26,638
DBP-WD 15k	DBpedia	15,000	42,294	52,134	19,132	38,265
	Wikidata	15,000	133,090	138,246	19,324	42,746

. The DBP-YG and DBP-WD include attribute triples representing the attribute information of the entities and relation triples representing the relations between the entities, respectively. At this time, the predicates and objects of the attribute triples contain many words describing the actual entities. On the other hand, the relation triples can only non-symbolically express only entities and their equivalence relationships, but no vocabularies can explain their meaning.

Comparison Methods

We conducted an experiment to evaluate the superiority of our proposed framework compared to the existing entity alignment methods. The details of the comparison methods are presented as follows.

(1)

MTransE: MtransE is an EA method which learns mapping between two separate embedding spaces of different KGs [31].

(2)

TransD: TransD is an embedding method which extends TransE to model complex relations by projecting the entities into a relation-related space [32].

(3)

RotatE: RotatE is an embedding method which represents entities as complex vectors and relations as rotations in a complex vector space [33].

(4)

ConvE: ConvE is an embedding method which is the representative multi-layer CNN-based architecture for link prediction [34].

(5)

AlignE: AlignE is a self-training entity alignment method which embeds two KGs in a unified space and iteratively labels newly identified entity alignment as supervision [30].

(6)

AttrE: AttrE generates attribute character embeddings to shift the entity embeddings from different two knowledge graphs into the same space [14].

(7)

GCN-a: GCN-Align is an entity alignment method which employs GCN to model entities to exploit their neighborhood information [30].

We conducted an experiment by varying the sampling ratio from 10 to 55% in increments of 5%. By convention, we chose Hit@k (k = 1, 5, 10), mean rank (MR), and mean reciprocal rank (MRR) as the evaluation metrics.

4.2. Experimental Results and Evaluation

The results of the experiment on the full datasets are illustrated in

Table 3. Experimental results on DBP-YG 15k and DBP-WD 15k.

Methods	DBP-YG					DBP-WD
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	47.343	68.771	74.305	249.55	0.5687	25.048	45.257	53.343	338.17	0.3468
TransD	31.124	45.495	49.219	1320.94	0.3773	20.99	34.562	40.114	1198.89	0.2947
RotatE	45.743	66.495	71.952	553.978	0.5491	26.533	46.981	55.81	511.24	0.3615
ConvE	5.886	10.152	11.429	4213.87	0.0788	14	25.648	30.086	1788.70	0.1958
AlignE	26.933	41.362	45.762	452.331	0.3364	16.219	28.095	34.457	390.17	0.2242
AttrE	28.79	67.41	71.886	901.239	0.5693	11.41	13.21	30.752	478.26	0.1124
GCN-a	46.638	62.895	66.314	1110.54	0.5383	26.59	48.248	62.552	712.40	0.4022
proposed	51.324	68.571	71.468	950.118	0.5883	33.257	57.19	64.752	581.04	0.4404

. As shown in Table 3, our proposed framework outperforms other comparison models. As our proposed method exploits semantic information with a language model, it captured the differences between entities better than the other comparison models. Moreover, the alignment models using attributes including our proposed model show better performances than the models using only relations. This is because the entities in KG have multiple aspects of features, which help in identifying equivalence relations.

Figure 5 and Figure 6 show the experimental results by changing the sampling rate for the two experimental datasets: DBP-YG 15k and DBP-WD 15k. There are a lot of data on the people-centered relationship in the DBP-YG 15k. In the case of people relationships, the complexity of the label is quite high because the types are quite diverse. Thus, the complexity of the label greatly increases according to the data sampling rate. While the value of Hits@1 increases with the stability, the value of Hits@10 increases slowly as the sampling rate increases. The value of Hits@10 increases steeply up to the sampling rate of 30%, and then the increase slows down after that the rate. This is because the entropy of the label increases as the complexity of the label increases. The increase rate of the Hits@K value of DBP-WD 15k was much slower. The proposed method showed excellent performance at almost all sampling rates and the closest performance with the GCN-a and AlignE. In the case of Hits@5 and Hits@10, the performance of AlingE is lower than the proposed method. It means that the generalization performance of AlingE is low.

On the other hand, for the MRR, the value of MRR increases rapidly as the sampling rate increases. Unlike Hits@k, the MR and MRR are indicators that can evaluate the generalization performance and stability because they calculate average scores for the overall results. At this time, the lower the MR, the better the value, and the higher the MRR, the better. As depicted in Figure 5, the proposed method performs better than the other methods at most sampling rates. In particular, the index of Hits@10 in the DBP-WD 15k dataset indirectly suggests that the generalization performance of the AlingE method is somewhat low. Furthermore, the MRR value also suggests that the performance of AlingE is low. As a result of comparing Hits@k, it can be confirmed that the proposed method showed high accuracy compared to the other methods. Moreover, it showed a high generalization performance from the perspective of the MR and MRR. In summary, it can be said that the entity alignment performance of the proposed method is excellent. The experimental results are summarized in

Table 4. Experimental results of DBP-YG 15k.

Methods	10%					15%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	5.219	11.743	15.133	989.475	0.087115	6.238	12.752	15.943	971.901	0.097091
TransD	1.229	2.362	2.81	4621.611	0.018651	1.133	2.286	2.876	4564.548	0.017878
RotatE	1.743	4.771	6.238	3606.116	0.033357	2.733	7.105	9.41	3078.689	0.050155
ConvE	0.41	0.838	1.124	4840.592	0.007365	0.438	0.981	1.305	4883.341	0.007749
AlignE	0.276	0.762	1.076	4062.907	0.006292	1.2	2.476	3.295	2647.197	0.020338
AttrE	3.571	10.048	12.343	3454.863	0.06459	4.943	12.552	15.305	2831.649	0.090642
GCN-a	3.819	8.552	11.314	2494.948	0.062887	7.838	14.61	17.571	2262.543	0.112049
proposed	3.489	8.162	10.581	2477.388	0.059166	5.981	11.829	14.419	2400.914	0.089217
Methods	20%					25%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	9.657	19.657	24.457	742.268	0.148495	12.667	25.21	31.019	638.397	0.189461
TransD	2.714	4.79	5.571	4292.445	0.037679	4.581	8.857	10	3783.594	0.065699
RotatE	3.61	9.333	12.2	2797.711	0.065277	5.867	14.019	18.086	2207.615	0.099234
ConvE	0.657	1.381	1.762	4825.704	0.011041	1.124	2.39	2.829	4626.725	0.017701
AlignE	1.714	3.733	4.838	2587.264	0.029026	1.752	3.838	5.248	2643.471	0.030305
AttrE	6.829	15.962	18.99	2828.178	0.109796	10.676	23.476	28.086	2168.71	0.164928
GCN-a	11.19	20.267	23.819	2014.289	0.155226	15.867	27.029	30.4	1873.262	0.209795
proposed	10.495	19.19	22.895	2057.617	0.146866	15.267	25.81	29.495	1897.483	0.202285
Methods	30%					35%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	14.571	27.21	32.752	659.049	0.207981	18.114	34.143	40.724	535.993	0.258659
TransD	5.629	9.857	11.486	3608.386	0.076879	7.057	13	14.695	3375.369	0.099554
RotatE	7.248	17.381	22.286	2101.093	0.122485	11.705	24.581	30.086	1728.132	0.178291
ConvE	1.533	3.19	3.905	4590.226	0.023763	1.476	2.905	3.657	4610.68	0.02259
AlignE	5.629	10.981	13.457	1473.699	0.085146	5.486	11.095	13.562	1437.927	0.08444
AttrE	13.352	26.952	31.505	1945.328	0.19539	22.114	40.632	47.743	1232.822	0.305168
GCN-a	18.048	29.095	32.714	1896.629	0.231485	22.276	34.971	38.829	1698.088	0.281175
proposed	18.4	29.6	33.295	1895.828	0.236035	20.714	32.895	36.4	1776.478	0.262811
Methods	40%					45%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	20.971	39.524	46.495	454.745	0.296396	21.905	39.267	45.819	495.842	0.301097
TransD	9.114	15.143	17.029	3173.499	0.119754	9.019	15.99	17.981	3119.059	0.122631
RotatE	12.276	26.057	31.924	1601.607	0.187436	13.533	27.943	34.095	1484.941	0.202817
ConvE	2.057	3.838	4.619	4524.897	0.030075	2.295	4.476	5.324	4486.752	0.034252
AlignE	6.39	11.695	14.581	1446.427	0.093288	10.01	18.619	22.19	973.676	0.143399
AttrE	24.962	43.724	50.724	1134.102	0.335602	25.724	44.686	51.067	1151.88	0.342782
GCN-a	24.762	38.314	42.381	1624.372	0.310143	27.371	41.314	44.781	1589.461	0.336441
proposed	25.676	39.21	43.352	1598.863	0.318712	27.352	41.448	45.143	1603.54	0.337185
Methods	50%					55%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	24.286	42.562	49.629	409.367	0.329354	27.362	46.305	53.657	419.483	0.362618
TransD	10.343	17.705	20.029	2965.64	0.137918	14.467	24.524	27.133	2388.665	0.191164
RotatE	19.152	36.924	43.39	1279.827	0.272637	20.552	37.829	44.457	1218.209	0.285249
ConvE	1.971	4.019	4.99	4473.383	0.030615	2.59	4.8	5.59	4428.979	0.037308
AlignE	9.352	17.257	20.676	1083.472	0.134112	12.486	21.467	24.943	937.215	0.169144
AttrE	31.59	52.457	59.362	842.895	0.408985	29.667	48.524	54.762	1052.755	0.38114
GCN-a	27.714	41.733	45.771	1575.704	0.341195	31.857	46.324	49.895	1516.203	0.383031
proposed	27.324	41.848	45.752	1583.95	0.338288	31.933	46.038	49.8	1471.284	0.382792

and

Table 5. Experimental results of DBP-WD 15k.

Methods	10%					15%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	2.867	4.057	5.267	6.924	7.352	9.905	9.838	11.4	13.086	13.457
TransD	0.543	1.057	1.324	1.952	1.648	2.381	3.552	6.076	5.352	8.724
RotatE	1.171	1.438	2.257	3.352	4.01	5.771	6.371	8.581	8.848	11.79
ConvE	0.648	1.01	1.686	1.79	1.971	2.59	3.076	5.029	4.638	6.105
AlignE	2.295	2.99	6.838	9.01	13.105	16.771	15.524	16.714	22.733	24.457
AttrE	0.724	1.095	1.857	4.257	2.381	5.257	6.048	5.086	8.076	8.476
GCN-a	3.419	6.838	9.19	10.867	11.162	14.476	17.133	18.143	19.143	20.695
proposed	3.505	6.314	9.086	11.771	12.638	15.562	18.2	19.533	20.781	22.352
Methods	20%					25%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	7.4	10.19	12.838	16.276	17.114	21.467	21.514	24.257	27.2	27.457
TransD	1.124	2.4	2.629	3.724	3.362	4.943	6.981	11.8	10.324	16.714
RotatE	3.333	4.829	6.562	9.676	10.59	15.429	15.61	21.057	21.571	26.705
ConvE	1.41	2.095	3.733	4.076	4.413	5.362	6.667	10.01	9.476	12.105
AlignE	6.067	8.257	16.743	20.619	27.438	31.819	31.629	32.867	40.981	41.219
AttrE	1.848	2.705	4.143	10.133	6.019	11.429	12.581	10.562	16.162	17.305
GCN-a	9.505	15.162	19.79	26.705	28.457	30.867	36.381	37.705	38.438	40.381
proposed	9.486	15.476	19.99	26.952	27.171	31.81	36.486	38.581	40.781	42.686
Methods	30%					35%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	10.276	14.476	17.467	21.552	22.61	27.762	27.895	30.6	34.124	34.924
TransD	1.4	2.99	3.4	4.743	4.276	6.21	8.429	14.571	12.848	19.876
RotatE	4.79	7.19	9.41	13.61	14.762	20.41	20.705	27.457	28.733	31.133
ConvE	1.933	2.819	4.762	5.505	5.41	6.981	8.686	12.733	11.99	15.133
AlignE	8.076	11.181	21.81	26.695	34.79	39.524	38.743	39.686	43.229	47.21
AttrE	2.714	3.905	5.61	13.59	8.01	15.467	17.162	14.01	21.152	21.629
GCN-a	12.2	20.2	24.562	30.962	32.781	38.505	40.895	44.514	46.676	48.448
proposed	12.686	19.705	26.152	33.381	33.429	31.81	42.829	45.705	47.886	50
Methods	40%					45%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	1221.425	15	927.487	727.49	686.476	698.003	626.808	604.047	559.855	513.457
TransD	4736.17	984.128	4270.81	3945.896	3975.951	3674.879	3288.595	2549.698	2713.822	2246.182
RotatE	3102.216	4266.845	2176.263	1829.48	1637.252	1429.006	1380.808	1135.571	1133.641	913.709
ConvE	4224.712	2617.677	3638.473	3334.057	3298.478	2974.917	2857.147	2679.893	2576.757	2390.898
AlignE	3492.316	4037.055	2078.83	1734.855	1360.511	1191.889	1293.725	1231.147	1200.99	1174.354
AttrE	2294.503	3171.241	1747.874	981.093	1502.616	890.287	747.924	1018.332	658.057	635.495
GCN-a	2010.815	2016.904	1554.313	1340.271	1272.228	1209.585	1158.042	1110.016	1077.508	1001.897
proposed	2040.767	1753.269	1510.275	1314.369	1225.511	1161.867	1024.251	939.965	930.52	880.781
Methods	50%					55%
	Hits@1	Hits@5	Hits@10	MR	MRR	Hits@1	Hits@5	Hits@10	MR	MRR
MTransE	0.055848	0.077011	0.094672	0.11994	0.127012	0.159518	0.159951	0.180099	0.203167	0.206554
TransD	0.008951	0.017951	0.021127	0.029597	0.026132	0.037958	0.052898	0.090054	0.07957	0.125669
RotatE	0.024405	0.033939	0.047453	0.06774	0.076139	0.107241	0.112064	0.148758	0.152711	0.191802
ConvE	0.011405	0.016633	0.02805	0.031304	0.032514	0.041788	0.050963	0.076791	0.072031	0.092388
AlignE	0.041729	0.056971	0.116859	0.147353	0.202163	0.241058	0.231496	0.24283	0.24094	0.232826
AttrE	0.015488	0.021923	0.03358	0.076079	0.044789	0.088023	0.099309	0.082397	0.124909	0.131767
GCN-a	0.063838	0.100417	0.140528	0.18437	0.190657	0.227521	0.271595	0.284596	0.284716	0.303919
proposed	0.066785	0.107928	0.145862	0.18817	0.195417	0.231434	0.264371	0.282398	0.299176	0.316887

in detail.

5. Related Works

5.1. KGs for Edge Computing

Many recent studies have been performed to develop and utilize KGs to support ESs. The functions of these KGs can be categorized into three types: (1) service data/information management, (2) device/sensor maintenance, and (3) security/privacy of the ES. Based on these categories, the related works on KGs for edge computing are summarized in

Table 6. KGs for edge computing.

Purpose	Functions			Ref.
	Service	Device	Security
Provide data integration and reasoning services to support data management in ES	O	O	X	[22]
Provide a group recommendation service of network document resources in ES	O	X	X	[35]
Perform a news recommendation service in edge computing environment	O	X	X	[36]
Provide interactive services of vehicles, such as traffic flow prediction and route arrangement	O	O	X	[37]
Data representation of the edge computing devices in manufacturing systems	O	O	X	[12]
Perform edge analytics to manage limited resources in ES	X	O	X	[38]
Integrate knowledge for industrial automation systems in edge computing environment	O	O	O	[39]
Make the consumption of KGs more reliable and faster in ESs	O	O	X	[40]
Detect anomalous activity in industrial systems	X	X	O	[41]
Provide security-aware data model and semantics in the dynamic collaboration environment	O	O	O	proposed

O: satisfied, X: dissatisfied.

.

Xu [22] proposed a KG inference-enabled data management system for edge computing, named SuccinctEdge, which is a compact, decompression-free, self-index, in-memory RDF store that can answer SPARQL queries, including those requiring reasoning services associated with some ontology. Wu [35] devised a group recommendation system for network document resource exploration using the KG and LSTM in edge computing. Yao [36] developed a news recommendation algorithm in an edge computing environment using KG and GNN. Shi [37] proposed a KG-empowered reasoning model, named TKGERM, to reason traffic information with multi-source data for edge computing-enabled IoV (Internet of Vehicles). Liu [12] devised a KG-based data representation method for IIoT (Industrial Internet of Things)-enabled cognitive manufacturing. Zhang [38] proposed an edge analytics method using KG construction and application to manage infrastructure resources such as CPU usage, memory capacity, network bandwidth, and the operating system of relevant devices. Doldy [39] proposed an energy-based model of neuro-symbolic reasoning on KGs to characterize industrial automation systems, integrating knowledge from different domains such as industrial automation, communications and cybersecurity. Marx [40] presented Knowledge Box (KBox), an approach for transparently shifting query execution on KGs to the edge, to make the consumption of KGs more reliable and faster in ESs. Garrido [41] applied machine learning on ES-specific KGs to detect intrusion and anomalous activity in industrial systems. Even though adopting KGs in the edge computing environment is gaining popularity, these KGs are developed for their specific purposes so that it is hard to directly utilize these KGs to support cooperation and collaboration between ESs. To effectively resolve the semantic heterogeneity of the data of each ES, the entities in different KGs should be aligned.

5.2. Entity Alignment for KG

5.2.1. Entity Alignment Methods

Entity alignment, which links the entities from different KGs that indicate the same real-world object, is gaining popularity in fusing knowledge from heterogeneous KGs. Entity alignment methods can be categorized into (1) translation-based models and (2) GNN-based models [19]. Translation-based models [14,30,31,42,43,44] perform entity alignment by utilizing translation-based embedding models, mostly TransE [45], which learn vector representations of the entities and relations. MTransE [31] generates the embedding of the entities and relations using TransE and provides transitions for each embedding vector to its counterparts in other spaces. BootEA [30] adopted the bootstrapping approach, which iteratively labels likely entity alignment as training data to learn embeddings and employs an alignment editing method to reduce error. AttrE [14] generates attribute character embeddings that shift the entity embeddings of two different KGs into the same space by calculating the similarity of the entities based on their attributes. ITransE/IPTransE [42] iteratively align entities via joint knowledge embeddings by encoding the entities and relations of different KGs into a single semantic space. Currently, ITransE utilizes TransE to learn embeddings while IPTransE utilizes PTransE [46]. JAPE [43] jointly embeds the structures of two KGs into a unified vector space and refines them by leveraging attribute correlations. KDCoE [44] iteratively trains two component embedding models on multilingual KG structures and entity descriptions, respectively.

GNN-based models utilize GNN to generate embeddings and predict alignment and can be divided into GCN-based models [47,48,49,50,51,52] and GAT-based models [53,54,55]. GCN-Align [52] trains GCNs to perform the embedding of the entities of different KGs into the same vector space. MuGNN [51] utilizes different channels for each KG to be robust to structural differences. GMNN [50] introduces the topic entity graph, which is a local sub-graph of the entity, to represent entities with their contextual information in KG. RDGCN [49] incorporates relation information by attentive interaction between the knowledge graph and its counterpart. HGCN [48] jointly learns entity and relation representations and does not require pre-aligned relations. EMGCN [47] utilizes multi-order graph convolutional networks to perform end-to-end, unsupervised entity alignment. KECG [55] utilizes GAT to embed entities into a single vector space by utilizing inner-graph structure and intra-graph alignment information. MRAEA [54] directly models cross-lingual entity embeddings by attending to the node’s incoming and outgoing neighbors and its connected relations. RAGA [53] adopts a self-attention mechanism to spread entity information to the relations and then aggregates relation information back to the entities.

Even though these alignment methods perform well in general-purpose KGs, such as DBpedia and YAGO, they cannot be directly applied in ES-specific KGs as their heterogeneity is much severe than that of general-purpose KGs. To align entities of ES-specific KGs, a novel method is needed which considers the unique characteristics of the ES-specific KGs.

5.2.2. Entity Alignment Applications

Entity alignment is utilized for many purposes related to enabling the integration of knowledge of heterogeneous sources. Zhang [56] utilized the entity alignment method to integrate knowledge related to maritime dangerous goods. Chong [27] tried to support the interoperability of depressive disorder-related knowledge. Hu [57] performed entity alignment to obtain semantic information from a biomedical knowledge base. Zhou [58] proposed an alignment method of point of interest (POI)-related entities to discover identical POIs in location-based services. Chen [59] tries to integrate multi-source heterogeneous electricity power data by aligning entities in multiple power knowledge graphs. Yang [60] proposed an entity alignment method of power grid-dispatching knowledge graphs. Zhu [61] tried to identify similar IoT devices in different networks by using an alignment method. These studies perform the alignment of entities related to their own purposes. However, in many cases, knowledge integration among different domains is needed, such as healthcare services and transportation. To meet this requirement, a novel alignment method is needed to perform alignment between KGs developed for different domains.

6. Conclusions and Further Research

This paper proposes the deep model-based dynamic entity alignment framework for edge-specific KGs in the edge computing environment. The contributions of this paper can be summarized as follows. First, we applied various deep learning models to align the domain-specific KGs. Second, as the domain-specific KGs of the edge computing environment do not have sufficient shared information, we proposed a method to perform alignment of the concepts from the different KGs by utilizing external information from general-purpose KG and documents. Finally, to ensure security and privacy of the domain-specific KGs of the edge computing environment, we proposed the GAN-based unsupervised alignment methods of the instances. The neural network models such as the GAN are black-box models that humans cannot interpret. So, they can ensure security by hiding the input data and hyperparameters of the model.

As a result, this paper proposes a novel entity alignment method suitable for the edge computing to overcome the limitations due to existing KG and entity alignment techniques not being suitable for real-world applications to edge computing environments. We analyzed the characteristics of edge-specific KGs that are different to general-purpose KGs, considering the edge computing and collaboration environment, and devised the entity alignment technique with the language model and GAN. In addition, various experiments were performed to evaluate the superiority of the proposed method, and it was proved that it exhibits a better performance than the conventional methods.

However, our framework has several limitations. As vector representation does not consider the structure of the KG and containing terms, the position of the entities projected by the language model may be biased. Moreover, in order to quickly respond to new types of cyberattacks, not only resources composed of formal sentences, but also noisy and fragmented text resources should also be used. To overcome these limitations, we will additionally use graph embedding methods which consider graph structures and utilize the language model which is more robust to short and noisy texts.