# OntoEA: Ontology-guided Entity Alignment
via Joint Knowledge Graph Embedding

Yuejia Xiang1,2111Equal contribution , Ziheng Zhang1111Equal contribution ,
Jiaoyan Chen3, Xi Chen1,2222Corresponding author , Zhenxi Lin1, Yefeng Zheng1
1Tencent Jarvis Lab, Shenzhen, China
2Platform and Content Group, Tencent, Shenzhen, China
3Department of Computer Science, University of Oxford, UK
<EMAIL_ADDRESS><EMAIL_ADDRESS>
<EMAIL_ADDRESS>

###### Abstract

Semantic embedding has been widely investigated for aligning knowledge graph
(KG) entities. Current methods have explored and utilized the graph structure,
the entity names, and attributes, but ignore the ontology (or ontological
schema) which contains critical meta information such as classes and their
membership relationships with entities. In this paper, we propose an ontology-
guided entity alignment method named OntoEA, where both KGs and their
ontologies are jointly embedded, and the class hierarchy and the class
disjointness are utilized to avoid false mappings. Extensive experiments on
seven public and industrial benchmarks have demonstrated the state-of-the-art
performance of OntoEA and the effectiveness of the ontologies.

##  1 Introduction

Knowledge graphs (KGs) that are composed of entities and facts in the RDF form
(i.e., RDF triples) are of vital importance in various applications, such as
search engines and personal assistants Hogan et al. (2020). Although there
have been several large-scale KGs, the content of one individual KG is often
incomplete, especially in supporting some domain-specific applications such as
clinical AI assistants. As these KGs are developed separately, they are
usually heterogeneous and supplementary to each other. Thus it becomes
urgently needed to align multiple KGs (i.e., matching the equivalent elements)
to fully explore their usability.

Figure 1: A class conflict example in entity alignment.

Recently, a few embedding-based methods have been proposed for entity
alignment (EA) Sun et al. (2020b); Zhang et al. (2020); Qi et al. (2021), in
which entities are embedded into vectors and the equivalent entities are
determined via calculating the similarity of their vectors. They extend the
embedding of one KG to the embedding of multiple KGs into one vector space by,
for instance, a transformation matrix, which is learnt from annotated mappings
(a.k.a. seed mappings). They also utilize the entity names and attributes
besides the graph structures for better performance. These methods, however,
all ignore the ontology (or ontological schema) which is an important part of
many KGs such as DBpedia Auer et al. (2008) and Wikidata Vrandečić and
Krötzsch (2014) as meta information for higher quality and usability. The
ontology typically contains hierarchical classes and properties, and
optionally defines some logical constraints such as the class disjointness,
the property domain and range Horrocks (2008). Meanwhile, the KG usually
clarifies the membership relationship between entities and classes.

The entity mappings by the above methods that do not exploit the ontologies
may induce some class conflicts. Considering the example in Fig. 1, Victoria
in $\text{KG}_{\text{1}}$ is often incorrectly aligned to VICTORIA in
$\text{KG}_{\text{2}}$ by many embedding-based methods, but they belong to two
potentially disjointed classes, namely Person and Organization. We find such
class conflicted mappings are quite common in the wrongly predicted mappings.
Considering the EN-FR-15K-V1 benchmark by Sun et al. (2020b), $42.2\%$ and
$55.7\%$ of the wrongly predicted mappings are class conflicted when running
BootEA Sun et al. (2018) and RSN4EA Guo et al. (2019), respectively. These
false positive mappings could be avoided if their ontologies are considered.

In this study, we propose an ontology-guided entity alignment method named
OntoEA, which enriches the embedded semantics and avoids wrong mappings by
exploring the class conflicts. OntoEA can work well in two contexts: (i) one
ontology is shared across the to-be-aligned KGs; (ii) the ontologies of the
to-be-aligned KGs are separated. The first context seems to follow a strict
assumption but is actually quite common. For example, DBpedia has multilingual
KGs (or versions) that share the same ontology, and in industrial scenarios,
it is preferred to create a common ontology and then construct different KGs
from different sources. The second context can be transformed into the first
context by pre-aligning the ontologies, using existing ontology alignment
systems such as PARIS Suchanek et al. (2011) and LogMap Jiménez-Ruiz et al.
(2012), and/or cost-sensitive human intervention.

There are two challenges to utilize the ontology. First, it is difficult to
embed two KGs together with the ontology, and as far as we know, there are
currently no such solutions. Second, the class conflicts, indicated by the
class disjointness in the ontology, are not all explicitly defined. Most of
them should be learned from the KGs and they actually vary from KG to KG. For
example, two classes Human and Animal are often disjointed in artwork KGs, but
Human may belong to Animal in biological KGs. To address these challenges, we
develop a joint embedding method that includes five modules for embedding the
KGs, the ontology, the class conflicts, the membership relationships, and the
seed mappings, respectively. Specifically, we develop a class conflict matrix
(CCM) to represent different kinds of class conflicts, including those
explicitly defined as disjoint, those indicated by the class hierarchy (e.g.,
sibling classes likely to be disjointed) and those plausible deduced from the
KGs.

To the best of our knowledge, OntoEA is the first to utilize the ontology and
the embedding for KG alignment. Extensive experiments on seven benchmarks have
verified the effectiveness of the ontology guidance with both one shared
ontology or two separated ontologies. OntoEA consistently outperforms the
state-of-the-art baselines on all the benchmarks. For example, it on average
achieves over $35\%$ higher Hits@1, Hits@5, and MRR than the best baseline on
MED-BBK-9K — a new and challenging industrial benchmark. Last but not least,
we extend the current benchmarks with ontologies and membership relationships.
The source code and benchmarks are publicly accessible at
https://github.com/ZihengZZH/OntoEA.

##  2 Methodology

###  2.1 Problem Statement

A KG is denoted as $G=(E,R,T)$, where $E,R,T$ are the sets of entities,
relations and triples, respectively. Each triple $(h,r,t)\in T$, includes a
head entity $h\in E$, a relation $r\in R$, and a tail entity $t\in E$. Their
embeddings are denoted as $\bm{h}$, $\bm{r}$, $\bm{t}$, respectively. For two
to-be-aligned KGs $G_{i}=(E_{i},R_{i},T_{i})$ and $G_{j}=(E_{j},R_{j},T_{j})$,
an entity mapping, denoted as $m=(e_{i},e_{j})$ where $e_{i}\in E_{i}$,
$e_{j}\in E_{j}$, indicates that $e_{i}$ and $e_{j}$ refer to the same real-
world object. The entity alignment (EA) task aims to find all the mappings $M$
between $E_{i}$ and $E_{j}$, where we assume a small set of known entity
mappings (or seed mappings) $M_{s}$ are given.

Each KG is assumed to be associated with an ontology, which contains
hierarchical classes and optionally disjoint constraints between classes. For
simplicity, we consider the classes as entities in KG and the subsumption
relationships between classes, often known as rdfs:subClassOf, as relations in
KG. The simplified ontology is therefore regarded as a graph. For KGs $G_{i}$
and $G_{j}$, their associated ontologies are represented as
$O_{i}=(C_{i},H_{i})$ and $O_{j}=(C_{j},H_{j})$, respectively. We simply
denote both $O_{i}$ and $O_{j}$ as $O=(C,H)$ if $G_{i}$ and $G_{j}$ share one
ontology (i.e., $O_{i}\equiv O_{j}$); otherwise we denote the merged ontology
after ontology alignment as $O=(C,H)$. Note $C_{i}$, $C_{j}$ and $C$ are the
class sets, while $H_{i}$, $H_{j}$ and $H$ are the triple sets with only the
subClassOf relation. Furthermore, the membership relationships, which link the
entities and the corresponding classes, are denoted as $B_{i}$ and $B_{j}$,
and e.g., $B_{i}$ links $G_{i}$ and $C$ via $b_{i}=(e_{i},c)$ where $e_{i}\in
E_{i}$ and $c\in C$. The class and membership embeddings are denoted as
$\bm{c}$ and $\bm{b}$, respectively.

Figure 2: The framework of OntoEA.

###  2.2 OntoEA Framework

As shown in Fig. 2, OntoEA includes five modules: (i) entity embedding which
embeds each KG into a separate embedding space; (ii) ontology embedding which
embeds the class hierarchical structure with a non-linear transformation;
(iii) confliction loss which incorporates all potential class conflicts in the
embeddings with the CCM; (iv) membership loss which incorporates the
membership relationships and enables the joint learning of the entity
embedding and the ontology embedding; (v) alignment loss which bridges the
embedding spaces of the to-be-aligned KGs via seed mappings. An iterative co-
training strategy is proposed to incorporate these five modules and the entity
mappings are predicted with a pre-defined similarity measure between the joint
embeddings.

###  2.3 Entity Embedding

To embed the KGs $G_{i}$ and $G_{j}$, we adopt the translation-based method
TransE Bordes et al. (2013) which interprets a triple $(h,r,t)$ as a
translation by the relation $r$ from $h$ to $t$. The margin-based loss of
$(h,r,t)$ is defined as $f_{e}(h,t)=||\bm{h}+\bm{r}-\bm{t}||_{2}$, where
$||\cdot||_{2}$ denotes the L2 norm. Besides, we extend the loss with a limit-
based scoring loss Zhou et al. (2017) to ensure the discrimination between the
positive and negative triples and also lower scores for positive triples:

$\begin{split}\mathcal{L}_{E}=\sum_{(h,t)\in
T}\sum_{(h^{\prime},t^{\prime})\in
T^{\prime}}\\{&[\gamma^{1}_{e}+f_{e}(h,t)-f_{e}(h^{\prime},t^{\prime})]_{+}\\\
&+\alpha_{e}[f_{e}(h,t)-\gamma^{2}_{e}]_{+}\\},\end{split}$ (1)

where $[\cdot]_{+}$ denotes the function $f(x)=\max(0,x)$, hyperparameters
$\gamma^{1}_{e}$ and $\gamma^{2}_{e}$ control the margins, $\alpha_{e}$
balances the margin-based loss and the limit-based loss, and $T^{\prime}$ is
the set of the negative triples with each triple sampled using the
$\epsilon$-truncated uniform negative sampling strategy Sun et al. (2018) to
distinguish two similar triples.

It is worth noting that this study focuses on the EA task and the joint
embedding challenge, and TransE is chosen due to its simplicity and
efficiency. Our OntoEA framework is open to other advanced KG embedding
methods, such as GCN Wang et al. (2018) and RSN Guo et al. (2019).

###  2.4 Ontology Embedding

The shared or merged ontology $O=(C,H)$ is composed of triples with the
subClassOf relation. For simplicity, a triple $(c_{h},r,c_{t})$ is written as
a class pair $(c_{h},c_{t})$ in $H$ where $r:=subClassOf$. Inspired by Hao et
al. (2019) on embedding the hierarchical graph structure, we calculate the
scoring loss of $(c_{h},c_{t})$ with a non-linear transformation,
$f_{o}(c_{h},c_{t})=||\tanh(\bm{W}_{o}\bm{c}_{h}+\bm{b}_{o})-\bm{c}_{t}||_{2}$,
where $\bm{W}_{o}\in\mathcal{R}^{d_{o}\times d_{o}}$ and
$\bm{b}_{o}\in\mathcal{R}^{d_{o}}$ are the learnable parameters, and $d_{o}$
denotes the ontology embedding dimension. This tends to encode each class as a
sphere and each subclass as a vector in the same semantic space after the non-
linear transformation, and the relative positions are employed to model the
relations between class and its subclass.

Similarly, we adopt the margin-based and limit-based loss for training:

$\begin{split}\mathcal{L}_{O}=\sum_{(c_{h},c_{t})\in
H}\sum_{(c^{\prime}_{h},c^{\prime}_{t})\in
H^{\prime}}\\{&[\gamma^{1}_{o}+f_{o}(c_{h},c_{t})-f_{o}(c^{\prime}_{h},c^{\prime}_{t})]_{+}\\\
&+\alpha_{o}[f_{o}(c_{h},c_{t})-\gamma^{2}_{o}]_{+}\\},\end{split}$ (2)

where $H^{\prime}$ denotes the set of negative class pairs with each pair
sampled by replacing $c_{h}$ or $c_{t}$ following the uniform negative
sampling strategy Bordes et al. (2013), while $\gamma^{1}_{o}$,
$\gamma^{2}_{o}$ and $\alpha_{o}$ are hyperparameters similar to
$\gamma^{1}_{e}$, $\gamma^{2}_{e}$ and $\alpha_{e}$ in Eq. 1.

Note that we do not directly utilize TransE in the ontology embedding, because
the subClassOf relation is transitive (e.g., we can infer (Royalty,
subClassOf, Agent) via (Royalty, subClassOf, Person) and (Person, subClassOf,
Agent) as shown in Fig. 1), which can lead to one-to-many and many-to-one
mappings (or triples) in the ontology, and TransE cannot well address the
relation with such transitive property Lv et al. (2018).

###  2.5 Confliction Loss

We use a class conflict matrix (CCM) to represent the inter-class conflicts
that are either explicitly defined by class disjointness or implicitly
discovered from the entities. Within the CCM, the entry on the $i^{\text{th}}$
row and $j^{\text{th}}$ column, denoted as $m_{i,j}$, represents the conflict
degree between class $c_{i}$ and class $c_{j}$. For one ontology, the CCM is a
squared and symmetric matrix, and we only maintain the upper triangular for
higher efficiency. Given two classes $c_{i}$ and $c_{j}$,
$m_{i,j}\in\left[0,1\right]$ is calculated as follows. First, we set
$m_{i,j}=0$ if $c_{i}\equiv c_{j}$, which ensures each class does not conflict
with itself. Second, $c_{i}$ and $c_{j}$ are regarded as fully conflicted,
i.e., $m_{i,j}=1$, if they are declared as disjointed by the ontology.111For
ontologies by Web Ontology Language (OWL), the class disjointness is common
and is usually defined as a constraint by the built-in relation
owl:disjointWith. Third, $c_{i}$ and $c_{j}$ are regarded as not conflicted,
i.e., $m_{i,j}=0$, if they have at least one common member (entity) or some of
their members are given as seed mapping (i.e., there exists $(e_{i},e_{j})$ in
$M_{s}$ such that $e_{i}$ belongs to $c_{i}$ and $e_{j}$ belongs to $c_{j}$).
Note the above three conditions are matched sequentially, and the computation
of $m_{i,j}$ is finished if any condition is met. Finally, if none of the
three conditions is met, we follow the principle that the farther two classes
are separated in the tree-like class hierarchy structure, the lower semantic
similarity and higher conflict degree the two classes have Mumtaz and Giese
(2020). To calculate the distance between $c_{i}$ and $c_{j}$, we use the set
of classes passed by routing from $c_{i}$ and $c_{j}$ to the root class,
denoted as $S(c_{i})$ and $S(c_{j})$, respectively, and then adopt the ratio
of the intersection of $S(c_{i})$ and $S(c_{j})$. Accordingly, we have
$m_{i,j}=1-\frac{|S(c_{i})\cap S(c_{j})|}{|S(c_{i})\cup S(c_{j})|}$ where
$|\cdot|$ denotes the set cardinality.

For the implicitly discovered conflicts, we assume the small conflict degree
between two classes if their embeddings are similar (i.e., high cosine
similarity). Thus we calculate another cosine similarity-based class conflict
degree: $d_{cos}(c_{i},c_{j})=1-\cos(\bm{c}_{i},\bm{c}_{j})$, where
$\bm{c}_{i}$ and $\bm{c}_{j}$ represent the embeddings of $c_{i}$ and $c_{j}$.
We propose to minimize the following negative log-likelihood loss to
incorporate the class conflicts represented by CCM into the class embeddings,

$\mathcal{L}_{C}=-\sum_{c_{i}\in C}\sum_{c_{j}\in C}m_{i,j}\log
d_{cos}(c_{i},c_{j}).$ (3)

###  2.6 Membership Loss

We develop the membership embedding module to utilize the membership
relationships, $B_{i}$ and $B_{j}$, to associate the KG embedding spaces with
the ontology embedding space, which is regarded as enhancing the KG embeddings
with the ontology semantics. Given one membership relationship $b=(e,c)$, we
utilize a non-linear transformation to map the entity embeddings to the
ontology embedding space, and we calculate the scoring loss as
$f_{m}(e,c)=||\tanh(\bm{W}_{m}\bm{e}+\bm{b}_{m})-\bm{c}||_{2}$ where
$\bm{W}_{m}\in\mathcal{R}^{d_{e}\times d_{o}}$ and
$\bm{b}_{m}\in\mathcal{R}^{d_{o}}$ are learnable parameters, $d_{e}$ and
$d_{o}$ denote the dimension of KG embedding and ontology embedding,
respectively. Similarly, we minimize the following margin-based and limit-
based loss to model all the membership relationships:

$\begin{split}\mathcal{L}_{M}=\sum_{(e,c)\in
B}\sum_{(e^{\prime},c^{\prime})\in
B^{\prime}}\\{&[\gamma^{1}_{m}+f_{m}(e,c)-f_{m}(e^{\prime},c^{\prime})]_{+}\\\
&+\alpha_{m}[f_{m}(e,c)-\gamma^{2}_{m}]_{+}\\},\end{split}$ (4)

where $B^{\prime}$ denotes the set of negative membership relationships with
each relationship created by replacing the class $c$ following the uniform
negative sampling strategy Bordes et al. (2013), and $\gamma^{1}_{m}$,
$\gamma^{2}_{m}$ and $\alpha_{m}$ are hyperparameters similar to
$\gamma^{1}_{e}$, $\gamma^{2}_{e}$ and $\alpha_{e}$ in Eq. 1.

###  2.7 Alignment Loss

For the alignment embedding module, OntoEA utilizes the seed mappings $M_{s}$
to bridge the embedding spaces of $G_{i}$ and $G_{j}$ such that the equivalent
mappings between two cross-KG entities can be calculated via some distance
metrics, such as cosine similarity. Given a seed mapping $m=(e_{i},e_{j})$,
its score is calculated as
$f_{a}(e_{i},e_{j})=||\bm{W}_{a}\bm{e}_{i}-\bm{e}_{j}||_{2}$ where
$\bm{W}_{a}\in\mathcal{R}^{d_{e}\times d_{e}}$ is a learnable translation
matrix, and the training loss is defined as,

$\mathcal{L}_{A}=\sum_{(e_{i},e_{j})\in M_{s}}f_{a}(e_{i},e_{j}).$ (5)

###  2.8 Iterative Co-Training and Prediction

To incorporate the aforementioned modules and obtain the embeddings of
$G_{i}$, $G_{j}$ and $O$, we can directly minimize the following loss:

$\mathcal{L}=\mathcal{L}_{E}+\mathcal{L}_{O}+\lambda_{1}\mathcal{L}_{C}+\lambda_{2}\mathcal{L}_{M}+\lambda_{3}\mathcal{L}_{A},$
(6)

where $\lambda_{1}$, $\lambda_{2}$, and $\lambda_{3}$ are hyperparameters that
balance the losses of confliction embedding, membership embedding and
alignment embedding, respectively. Instead of directly optimizing
$\mathcal{L}$, we use an iterative co-training strategy in OntoEA to reduce
model complexity and accelerate model convergence. At each iteration, OntoEA
first optimizes $\mathcal{L}_{E}$ and $\mathcal{L}_{O}$ independently, then
sequentially optimizes $\mathcal{L}_{C}$ and $\mathcal{L}_{M}$, and finally
optimizes $\mathcal{L}_{A}$. The iteration stops until some stopping criterion
on the validation set is met.

With the embeddings of $G_{i}$, $G_{j}$ and $O$, we calculate the entity
mappings with the cosine similarity. Given two entities $e_{i}\in G_{i}$ and
$e_{j}\in G_{j}$, the weighted similarity score is calculated as:

$sim(e_{i},e_{j})=\beta\cos(\bm{e}_{i},\bm{e}_{j})+(1-\beta)\cos(\bm{c}_{i},\bm{c}_{j}),$
(7)

where hyperparameter $\beta\in\left[0,1\right]$ balances the similarities of
entity embeddings and class embeddings. It is possible that one entity has
multiple classes declared; for example, Victoria in Fig. 1 can be an entity of
Royalty and another class like Female Leader. In this case we calculate the
average of the embeddings of all the declared classes as the class embedding
($\bm{c}_{i}$ or $\bm{c}_{j}$).222Note that we do not consider the inferred
classes, such as Person for Victoria in Fig. 1. In the prediction, for each
entity in $G_{i}$ to be aligned, we rank all candidate entities in $G_{j}$ by
their weighted similarity scores.

##  3 Benchmarks

###  3.1 Benchmark Details

For comprehensive evaluation, we adopt six popular EA benchmarks including EN-
FR-15K-V1/V2, EN-DE-15K-V1/V2 and D-W-15K-V1/V2 from Sun et al. (2020b), and
an industrial benchmark MED-BBK-9K from Zhang et al. (2020). Note that for the
cross-lingual benchmarks within DBpedia (i.e., EN-FR and EN-DE), the to-be-
aligned KGs share one ontology, while for the other benchmarks, the to-be-
aligned KGs have different ontologies that need to be aligned beforehand.

The benchmarks themselves do not include ontologies, and we thus extract and
append an ontology for each KG, which includes the class structure (i.e.,
rdfs:subClassOf relationships) and membership relationships. Each benchmark
therefore contains two KGs, their ontologies, and associated membership
relationships. The benchmark statistics are shown in Table 1 where “-15K” and
“9K” in the benchmark names are omitted. For the KGs of DBpedia, we use the
DBpedia ontology and the membership relationships from the DBpedia SPARQL
endpoint333http://dbpedia.org/sparql by querying the classes of each entity
with rdfs:type. Note we also utilize the defined class disjointness
constraints by owl:disjointWith for initializing CCM. For the two Wikidata KGs
in D-W-V1/V2, we extract their ontologies and membership relationships from
the Wikidata SPARQL endpoint444https://query.wikidata.org/sparql using queries
with rdfs:subClassOf and rdfs:type. For the KGs of the industrial benchmark,
we use domain knowledge (with the assistance of medical experts) to construct
a shared, small-scale, but high-quality ontology, and the corresponding
membership relationships.

Table 1: Statistics of the benchmarks.

Dataset |  KG |  Ontologyb |  Membershipc
---|---|---|---
|  |  #Cls. |  #Trs. |  #Links |  #Roots
share-Oa | EN-FR-V1 | EN/FR |  189 |  755 |  15,000 |  639
EN-FR-V2 | EN/FR |  104 |  755 |  15,000 |  533
EN-DE-V1 | EN/DE |  175 |  755 |  15,000 |  155
EN-DE-V2 | EN/DE |  86 |  755 |  15,000 |  165
MED-BBK | MED |  11 |  10 |  9,162 |  86
BBK |  11 |  10 |  9,162 |  3,362
not-share-O | D-W-V1 | DB |  172 |  755 |  15,000 |  306
WK |  140 |  695 |  15,000 |  342
D-W-V2 | DB |  71 |  755 |  15,000 |  463
WK |  68 |  695 |  15,000 |  418
|  |  |  |  |  |

  * a

“share-O” means the to-be-aligned KGs share one ontology while “not-share-O”
means the to-be-aligned KGs have different ontologies.

  * b

“#Cls.” denotes the number of classes and “#Trs.” denotes the number of
rdfs:subClassOf relation triples.

  * c

“#Roots” denotes the number of entities that have no rdf:type property and are
linked to the root class.

  * d

See Table 6 in the Appendix for more benchmark statistics.

###  3.2 Ontology Alignment

For the benchmarks whose KGs do not share one ontology, we first align the
ontologies. We adopt two ontology alignment methods: manual annotation and
alignment system. In the first method, we employ five annotators to annotate
class mappings for each ontology pair and the classes annotated by more than
three annotators are adopted. It is worth noting that the manual annotation of
class mappings is worthwhile and often adopted in KG construction and curation
because of the high quality and relatively small scale in comparison with the
entity mappings. In the second method, we apply a state-of-the-art ontology
alignment system named PARIS555http://webdam.inria.fr/paris/ and some ad-hoc
pre-processing and post-processing for automatic class mapping computation.
Please see Appendix C for more details on ontology alignment and merging. For
the D-W benchmarks, we considered both methods and compared their performance
(see Table 4).

##  4 Experiments

Table 2: Overall results of OntoEA and the baselines.

Models | EN-FR-15K-V1 | EN-FR-15K-V2 | D-W-15K-V1 | D-W-15K-V2 |  MED-BBK-9K
---|---|---|---|---|---
| H@1 | H@5 | MRR | H@1 | H@5 | MRR | H@1 | H@5 | MRR | H@1 | H@5 | MRR | H@1 | H@5 | MRR
w/o SI | MTransE | .247 | .467 | .351 | .240 | .436 | .336 | .259 | .461 | .354 | .271 | .490 | .376 | .004 | .014 | .012
JAPE | .262 | .497 | .372 | .292 | .524 | .402 | .250 | .457 | .348 | .262 | .484 | .368 | .003 | .009 | .009
SEA | .280 | .530 | .397 | .360 | .651 | .494 | .360 | .572 | .458 | .567 | .770 | .660 | .199 | .375 | .287
GCNAlign | .338 | .589 | .451 | .414 | .698 | .542 | .364 | .580 | .461 | .506 | .743 | .612 | .065 | .153 | .117
BootEA | .507 | .718 | .603 | .660 | .850 | .745 | .572 | .744 | .649 | .821 | .926 | .867 | .307 | .495 | .399
RSN4EA | .393 | .595 | .487 | .579 | .759 | .662 | .441 | .615 | .521 | .723 | .854 | .782 | .195 | .311 | .253
AliNet | .258 | .437 | .339 | .359 | .569 | .453 | .270 | .403 | .331 | .522 | .698 | .601 | .017 | .042 | .033
| OntoEA | .566 | .818 | .678 | .654 | .891 | .757 | .591 | .808 | .688 | .814 | .950 | .873 | .343 | .546 | .440
Improv. best % | 11.6 | 13.9 | 12.4 | -0.9 | 4.8 | 1.6 | 3.3 | 8.6 | 6.0 | -0.9 | 2.6 | 0.7 | 11.7 | 10.3 | 10.3
w/ SI | AttrE | .481 | .671 | .569 | .535 | .746 | .631 | .299 | .467 | .381 | .489 | .695 | .585 | .194 | .363 | .279
MultiKE | .749 | .819 | .782 | .864 | .909 | .885 | .411 | .521 | .468 | .495 | .646 | .569 | .213 | .367 | .289
RDGCN | .755 | .854 | .800 | .847 | .919 | .880 | .515 | .669 | .584 | .623 | .757 | .684 | .306 | .425 | .365
OntoEA | .797 | .871 | .832 | .901 | .981 | .931 | .553 | .787 | .656 | .795 | .943 | .860 | .517 | .703 | .604
Improv. best % | 5.6 | 2.0 | 4.0 | 4.3 | 6.7 | 5.2 | 7.4 | 17.6 | 12.3 | 27.6 | 24.6 | 25.7 | 68.9 | 65.4 | 65.5
|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |

###  4.1 Experimental Setup

We compare OntoEA against state-of-the-art EA models including four
translation-based models, MTransE Chen et al. (2017); JAPE Sun et al. (2017);
SEA Pei et al. (2019); BootEA Sun et al. (2018), two graph neural network
based models, GCNAlign Wang et al. (2018); AliNet Sun et al. (2020a), and one
recurrent neural network based model, RSN4EA Guo et al. (2018). We also
compare OntoEA against some state-of-the-art models that additionally utilize
entity surface information (SI) (i.e., entity names) including AttrE Trisedya
et al. (2019), MultiKE Zhang et al. (2019) and RDGCN Wu et al. (2019). Since
using and not using SI are usually regarded as two different evaluation
contexts Guo et al. (2019), we separately evaluate OntoEA without (w/o) and
with (w/) SI. Note that OntoEA with SI is implemented by a simple but
effective strategy which initializes the embeddings of the translation-based
models in Section 2.3 and Section 2.4 (i.e., $\bm{h}$, $\bm{r}$, $\bm{t}$ and
$\bm{c}$) with the pre-trained word embeddings of their names. As in Sun et
al. (2020b), we use the unified multi-lingual word embeddings fastText
Bojanowski et al. (2017) for the cross-lingual benchmarks.666The word
embeddings are publicly available at https://fasttext.cc/docs/en/crawl-
vectors.html. All the results of AliNet, and the results of MTransE, JAEP, SEA
and GCNAlign on MED-BBK-9K are reproduced locally; while the other baseline
results are taken from Sun et al. (2020b) and Zhang et al. (2020). We follow
the same train ($20\%$), validation ($10\%$) and test ($70\%$) splits as Sun
et al. (2020b) and Zhang et al. (2020).

We implement OntoEA upon the open source library
OpenEA777https://github.com/nju-websoft/OpenEA. We use the AdaGrad optimizer
with a learning rate of $0.01$. The batch sizes for entity embedding and
ontology embedding are set to 4500 and 64, respectively, and their dimensions
are both set to 300. The weight hyperparameters are set as $\lambda_{1}=1$,
$\lambda_{2}=1$, $\lambda_{3}=5$ and $\beta=0.5$, and other hyperparameters
are set as $\gamma^{1}_{x}=0.01$, $\gamma^{2}_{x}=2.0$ and $\alpha_{x}=0.2$
for all the losses where $x\in\\{e,o,m\\}$. These hyperparamters are tuned
w.r.t. the MRR on the validation set. Please see Appendix B for more
implementation details.

With the embeddings we use the nearest neighbor search with cross-domain
similarity local scaling Lample et al. (2018) to calculate the entity matching
of each to-be-aligned entity. In the evaluation, we rank matching candidates
of each to-be-aligned entity and calculate the metrics of Hits@1 (H@1), Hits@5
(H@5) and mean reciprocal rank (MRR). In the following tables, the best
(second best resp.) result is bolded (underlined resp.).

Figure 3: Results of OntoEA and some baselines on test entity mappings with
different summed degrees.

###  4.2 Overall Results

Table 2 reports the overall results of OntoEA and the baselines.888Results on
the two EN-DE benchmarks, which lead to similar findings as the EN-FR
benchmarks, are shown in Table 7 in the Appendix. Overall, in both contexts of
using and not using SI, OntoEA performs the best across all the benchmarks on
all the metrics, except for H@1 on EN-DE-15K-V2 and D-W-15K-V2.

Without SI. Regarding the benchmarks that share one ontology, OntoEA achieves
at least $10\%$ higher performance in all the metrics over the best baseline
BootEA on EN-FR-15K-V1 which has sparse KG structures. On EN-FR-15K-V2 with
dense KG structures, OntoEA achieves higher H@5 and MRR but competitive H@1 in
comparison with the best baseline. For the D-W benchmarks whose KGs have
different ontologies, we have a similar finding: the outperformance of OntoEA
is more significant on the benchmark with sparse KG structures (i.e.,
D-W-15K-V1) than on the benchmark with dense KG structures (i.e., D-W-15K-V2).
On the one hand, dense KG structures indicate that more information can be
utilized with better performance, and relatively the additional positive
impact by the ontology becomes more limited. On the other hand, the ontologies
of both EN-FR-15K-V2 and D-W-15K-V2 coincidentally have fewer classes (see
Table 1), which would also lead to a lower impact of the ontology guidance.
Regarding the industrial MED-BBK-9K, which is quite new and has shown more
challenging w.r.t. these baselines Zhang et al. (2020), OntoEA outperforms the
best baseline by more than 10% in all the metrics. Although its ontology has a
limited scale, the ontology is of high quality as it is specifically created
with the domain knowledge.

With SI. OntoEA shows very promising overall results as OntoEA without SI. It
outperforms all the baselines on all the benchmarks, with the improvements
over the best baseline ranging from $2\%$ to $68.9\%$. Regarding the
industrial MED-BBK-9K, the performance improvement of OntoEA is especially
significant with more than 60% in all the metrics. As aforementioned, this
benchmark is challenging to these baselines and it has high-quality
ontologies. It is worth mentioning that on the D-W benchmarks, the involvement
of SI deteriorates the performance of OntoEA and the best baseline, while the
positive impact of the ontologies (i.e., the performance gain of OntoEA over
the best baseline) becomes more significant.

###  4.3 Ablation Studies

Model Component Analysis. To investigate different components in OntoEA, we
compare OntoEA variants without the CCM loss (w/o $\mathcal{L}_{C}$), without
the membership relationship loss (w/o $\mathcal{L}_{M}$), and without the
ontology (w/o Onto.). The experimental results of OntoEA w/o SI on EN-
FR-15K-V1/V2 are reported in Table 3, which shows that $\mathcal{L}_{M}$
contributes more to OntoEA than $\mathcal{L}_{C}$ as removing it leads to a
larger performance drop. The results OntoEA w/ SI show similar findings and
are thus omitted. As expected, the removal of the ontology deteriorates
performance the most. All these results verify the significant role of the
ontologies and their associated class conflicts and membership relationships.

Table 3: Results of OntoEA w/o SI and its variants with the removal of
different components.

Models | EN-FR-15K-V1 | EN-FR-15K-V2
---|---|---
H@1 | H@5 | MRR | H@1 | H@5 | MRR
OntoEA | .566 | .818 | .678 | .654 | .891 | .757
w/o $\mathcal{L}_{C}$ | .520 | .781 | .636 | .589 | .845 | .701
w/o $\mathcal{L}_{M}$ | .481 | .750 | .601 | .549 | .810 | .665
w/o Onto. | .430 | .698 | .551 | .545 | .814 | .664
|  |  |  |  |  |

Results on Different Test Entity Mappings. We split the test mappings
according to the summed degree, i.e.,
$\text{deg}(e_{i},e_{j}):=\text{deg}(e_{i})+\text{deg}(e_{j})$ where
$(e_{i},e_{j})$ are the entity mappings. We select three different
experimental settings (benchmarks and usage of SI) and Fig. 3 shows the
results of OntoEA and some competitive baselines on different degree
intervals. On EN-FR-15K-V1, OntoEA outperforms the baselines on all the
intervals and the performance gap reaches the highest on [0,10). On EN-
FR-15K-V2 with dense KG structures, OntoEA performs close to or slightly worse
than BootEA on intervals [10,20) and [20,30) but outperforms all the baselines
on the other intervals. On MED-BBK-9K, OntoEA performs much better than the
baselines on all the intervals. All these observations are consistent with our
findings from the overall results in Table 2 and also verify the effectiveness
of OntoEA on different test entity mappings.

Figure 4: The class conflict ratios.

Analysis of Class Conflicts. This part analyses the predicted mappings that
have class conflicts, with the results shown in Fig. 4. Note that the class
conflict ratio of a method is the rate of its false positive mappings with
class conflicts among all its false positive mappings. On EN-FR-15K-V1 and EN-
FR-15K-V2, OntoEA significantly decreases the class conflict ratio to $3\%$
and $0.3\%$, respectively, much lower than those of the baselines. On MED-
BBK-9K, OntoEA reduces the class conflict ratio to $34.0\%$ while MultiKE and
RDGCN have $51.5\%$ and $60.1\%$, respectively. The above observations
illustrate that OntoEA has effectively implemented our motivation of using the
ontologies and class conflicts to avoid false positive mappings.

Analysis of Ontology Alignment Methods. As the case that the to-be-aligned KGs
have different ontologies is common, we analyse the impact of different
ontology alignment methods proposed in Sec. 3.2, with the results in Table 4.
We find that OntoEA with manual annotation achieves better results than OntoEA
using the PARIS based alignment system method; the latter, however, still has
competitive or better results in comparison with the best baseline (i.e.,
BootEA or RDGCN). This also provides motivations for the future research and
industrial deployment work on iterative ontology alignment to keep a balance
between the annotation cost and the alignment quality.

Table 4: Results of OntoEA using different ontology alignment methods where
“-M” denotes the manual annotation while “-A” denotes the alignment system.

| Models | D-W-15K-V1 | D-W-15K-V2
---|---|---|---
| H@1 | H@5 | MRR | H@1 | H@5 | MRR
w/o SI |  OntoEA-M | .591 | .808 | .688 | .814 | .950 | .873
OntoEA-A | .572 | .795 | .673 | .762 | .907 | .827
BootEA | .572 | .744 | .649 | .821 | .926 | .867
w/ SI |  OntoEA-M | .553 | .787 | .656 | .795 | .943 | .860
OntoEA-A | .510 | .758 | .621 | .737 | .893 | .808
RDGCN | .515 | .669 | .584 | .623 | .757 | .684
|  |  |  |  |  |  |

##  5 Related Work

Embedding-based KG Alignment. These methods can be categorised into
translation-based, GNN-based and RNN-based. The translation-based methods
mainly rely upon some translation-based KG embedding models; for example,
MTransE adopts TransE and various mapping losses to align cross-lingual KGs
Chen et al. (2017). To utilize more useful information in the KG, JAPE embeds
the to-be-aligned KGs into one unified vector space via leveraging attribute
correlations Sun et al. (2017); AttrE exploits attributes by generating
attribute character embeddings Trisedya et al. (2019); and MultiKE makes full
use of entity names, entity attributes and graph structures via multi-view
learning Zhang et al. (2019). The GNN-based methods are typically based on GNN
variants for KG embedding, such as Graph Convolutional Networks (GCNs) Wang et
al. (2018), dual-primal GCNs Sun et al. (2020a), and GCNs with attentive
aggregation Sun et al. (2020a). As an RNN-based method, RSN4EA generates
biased random walks on KGs and learns the embeddings by a recurrent skipping
network Guo et al. (2019). Some work has explored a semi-supervised learning
setting, and for instance, BootEA Sun et al. (2018) adopts the bootstrapping
strategy to iteratively append new likely mappings during the learning
process.

KG Embedding with Ontology. Only a few attempts have been made towards the KG
embedding with ontology. The most relevant work is JOIE Hao et al. (2019)
which embeds the KG and the ontology in two embedding spaces and enables them
to enhance each other by the cross-view links i.e., membership relationships.
Some ontology embedding methods such as OWL2Vec* Chen et al. (2021a) can be
extended to jointly embed KG plus ontology since the KG can be regarded as an
assertion part (ABox) of the ontology. However, as far as we know, there are
currently no embedding methods that support two KGs along with their
ontologies, let alone utilize the ontologies to augment embedding-based KG
alignment.

##  6 Conclusions

This paper presented a novel method OntoEA to augment embedding-based entity
alignment with the ontology. OntoEA enriches the semantics of KG embeddings by
jointly learning the KGs, the ontology, the membership relationships and the
seed mappings, and utilizes the potential class conflicts to avoid false
mappings. The evaluation on multiple benchmarks has showed that OntoEA could
achieve state-of-the-art performance and reduce the false positive mappings
with class conflicts. For future work, we plan to utilize other ontology
semantics besides the class hierarchy and class disjointness constraints Chen
et al. (2021b). We also plan to extend the entity embedding module with other
advanced KG embedding methods.

## References

  * Auer et al. (2008) Sören Auer, Chris Bizer, Georgi Kobilarov, Jens Lehmann, Richard Cyganiak, and Zachary Ives. 2008.  DBpedia: A nucleus for a web of open data.  In _Proceedings of the 6th International Semantic Web Conference_ , volume 4825 of _Lecture Notes in Computer Science_ , pages 722–735. Springer.
  * Bojanowski et al. (2017) Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. 2017.  Enriching word vectors with subword information.  _Transactions of the Association for Computational Linguistics_ , 5:135–146.
  * Bordes et al. (2013) Antoine Bordes, Nicolas Usunier, Alberto García-Durán, Jason Weston, and Oksana Yakhnenko. 2013.  Translating embeddings for modeling multi-relational data.  In _27th Annual Conference on Neural Information Processing Systems 2013_ , pages 2787–2795.
  * Chen et al. (2021a) Jiaoyan Chen, Pan Hu, Ernesto Jiménez-Ruiz, Ole Magnus Holter, Denvar Antonyrajah, and Ian Horrocks. 2021a.  OWL2Vec*: Embedding of OWL ontologies.  _Machine Learning_.
  * Chen et al. (2021b) Jiaoyan Chen, Ernesto Jimenez-Ruiz, Ian Horrocks, Denvar Antonyrajah, Ali Hadian, and Jaehun Lee. 2021b.  Augmenting ontology alignment by semantic embedding and distant supervision.  In _Proceedings of the 18th Extended Semantic Web Conference_ , pages 1–16, Heraklion, Greece.
  * Chen et al. (2017) Muhao Chen, Yingtao Tian, Mohan Yang, and Carlo Zaniolo. 2017.  Multilingual knowledge graph embeddings for cross-lingual knowledge alignment.  In _Proceedings of the Twenty-Sixth International Joint Conference on Artificial Intelligence, IJCAI 2017_ , pages 1511–1517. ijcai.org.
  * Guo et al. (2018) Lingbing Guo, Zequn Sun, Ermei Cao, and Wei Hu. 2018.  Recurrent skipping networks for entity alignment. _CoRR_ , abs/1811.02318.
  * Guo et al. (2019) Lingbing Guo, Zequn Sun, and Wei Hu. 2019.  Learning to exploit long-term relational dependencies in knowledge graphs.  In _Proceedings of the 36th International Conference on Machine Learning, ICML 2019_ , volume 97 of _Proceedings of Machine Learning Research_ , pages 2505–2514. PMLR.
  * Hao et al. (2019) Junheng Hao, Muhao Chen, Wenchao Yu, Yizhou Sun, and Wei Wang. 2019.  Universal representation learning of knowledge bases by jointly embedding instances and ontological concepts.  In _Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019_, pages 1709–1719. ACM.
  * Hogan et al. (2020) Aidan Hogan, Eva Blomqvist, Michael Cochez, Claudia d’Amato, Gerard de Melo, Claudio Gutierrez, José Emilio Labra Gayo, Sabrina Kirrane, Sebastian Neumaier, Axel Polleres, Roberto Navigli, Axel-Cyrille Ngonga Ngomo, Sabbir M. Rashid, Anisa Rula, Lukas Schmelzeisen, Juan Sequeda, Steffen Staab, and Antoine Zimmermann. 2020.  Knowledge graphs.  _CoRR_ , abs/2003.02320.
  * Horrocks (2008) Ian Horrocks. 2008.  Ontologies and the semantic web.  _Communications of the ACM_ , 51(12):58–67.
  * Jiménez-Ruiz et al. (2012) Ernesto Jiménez-Ruiz, Bernardo Cuenca Grau, Yujiao Zhou, and Ian Horrocks. 2012\.  Large-scale interactive ontology matching: algorithms and implementation.  In _Proceedings of the 20th European Conference on Artificial Intelligence_ , pages 444–449.
  * Lample et al. (2018) Guillaume Lample, Alexis Conneau, Marc’Aurelio Ranzato, Ludovic Denoyer, and Hervé Jégou. 2018.  Word translation without parallel data.  In _International Conference on Learning Representations_.
  * Lv et al. (2018) Xin Lv, Lei Hou, Juanzi Li, and Zhiyuan Liu. 2018.  Differentiating concepts and instances for knowledge graph embedding.  In _Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing_ , pages 1971–1979, Brussels, Belgium. Association for Computational Linguistics.
  * Mumtaz and Giese (2020) Summaya Mumtaz and M. Giese. 2020.  Frequency-based vs. knowledge-based similarity measures for categorical data.  In _AAAI Spring Symposium: Combining Machine Learning with Knowledge Engineering_.
  * Pei et al. (2019) Shichao Pei, Lu Yu, Robert Hoehndorf, and Xiangliang Zhang. 2019.  Semi-supervised entity alignment via knowledge graph embedding with awareness of degree difference.  In _The World Wide Web Conference, WWW 2019_ , pages 3130–3136. ACM.
  * Qi et al. (2021) Zhiyuan Qi, Ziheng Zhang, Jiaoyan Chen, Xi Chen, Yuejia Xiang, Ningyu Zhang, and Yefeng Zheng. 2021.  Unsupervised knowledge graph alignment by probabilistic reasoning and semantic embedding.  _arXiv preprint arXiv:2105.05596_.
  * Suchanek et al. (2011) Fabian M. Suchanek, Serge Abiteboul, and Pierre Senellart. 2011.  PARIS: Probabilistic alignment of relations, instances, and schema. _Proc. VLDB Endow._ , 5(3):157–168.
  * Sun et al. (2017) Zequn Sun, Wei Hu, and Chengkai Li. 2017.  Cross-lingual entity alignment via joint attribute-preserving embedding. In _International Semantic Web Conference_ , volume 10587 of _Lecture Notes in Computer Science_ , pages 628–644. Springer.
  * Sun et al. (2018) Zequn Sun, Wei Hu, Qingheng Zhang, and Yuzhong Qu. 2018.  Bootstrapping entity alignment with knowledge graph embedding.  In _Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI 2018_ , pages 4396–4402. ijcai.org.
  * Sun et al. (2020a) Zequn Sun, Chengming Wang, Wei Hu, Muhao Chen, Jian Dai, Wei Zhang, and Yuzhong Qu. 2020a.  Knowledge graph alignment network with gated multi-hop neighborhood aggregation. In _Proceedings of the Conference on Artificial Intelligence_ , pages 222–229. AAAI Press.
  * Sun et al. (2020b) Zequn Sun, Qingheng Zhang, Wei Hu, Chengming Wang, Muhao Chen, Farahnaz Akrami, and Chengkai Li. 2020b.  A benchmarking study of embedding-based entity alignment for knowledge graphs. _Proc. VLDB Endow._ , 13(11):2326–2340.
  * Trisedya et al. (2019) Bayu Distiawan Trisedya, Jianzhong Qi, and Rui Zhang. 2019.  Entity alignment between knowledge graphs using attribute embeddings. In _Proceedings of the Conference on Artificial Intelligence_ , pages 297–304. AAAI Press.
  * Vrandečić and Krötzsch (2014) Denny Vrandečić and Markus Krötzsch. 2014.  Wikidata: A free collaborative knowledgebase.  _Communications of the ACM_ , 57(10):78–85.
  * Wang et al. (2018) Zhichun Wang, Qingsong Lv, Xiaohan Lan, and Yu Zhang. 2018.  Cross-lingual knowledge graph alignment via graph convolutional networks.  In _Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing_ , pages 349–357, Brussels, Belgium. Association for Computational Linguistics.
  * Wu et al. (2019) Yuting Wu, Xiao Liu, Yansong Feng, Zheng Wang, Rui Yan, and Dongyan Zhao. 2019.  Relation-aware entity alignment for heterogeneous knowledge graphs.  In _Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI 2019_ , pages 5278–5284. ijcai.org.
  * Zhang et al. (2019) Qingheng Zhang, Zequn Sun, Wei Hu, Muhao Chen, Lingbing Guo, and Yuzhong Qu. 2019\.  Multi-view knowledge graph embedding for entity alignment.  In _Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI 2019_ , pages 5429–5435. ijcai.org.
  * Zhang et al. (2020) Ziheng Zhang, Jiaoyan Chen, Xi Chen, Hualuo Liu, Bo Liu, YueJia Xiang, and Yefeng Zheng. 2020.  An industry evaluation of embedding-based entity alignment.  In _Proceedings of the 28th International Conference on Computational Linguistics: Industry Track_ , pages 179–189, Online. International Committee on Computational Linguistics.
  * Zhou et al. (2017) Xiaofei Zhou, Qiannan Zhu, Ping Liu, and Li Guo. 2017.  Learning knowledge embeddings by combining limit-based scoring loss.  In _Proceedings of the 2017 ACM on Conference on Information and Knowledge Management, CIKM 2017_ , pages 1009–1018. ACM.

## Appendix

##  Appendix A More Benchmark Details

Table 6 shows the full statistics of all the benchmarks used in the
experiments, including four cross-lingual benchmarks and two cross-KG
benchmarks from OpenEA Sun et al. (2020b), and one recent industrial cross-KG
benchmark from Zhang et al. (2020). We report the benchmark statistics from
three perspectives: the ontologies, the KGs and the membership relationships.
The benchmarks are divided as previous work that 20%, 10% and 70% of all the
entity mappings are used as training, validation and test sets, respectively
Sun et al. (2020b); Zhang et al. (2020).

##  Appendix B More Implementation Details

Our experiments are conducted on a workstation with an Intel Xeon E5 2.40 GHz
CPU, 128 GB memory, an NVIDIA Tesla M40 GPU, and CentOS 7.2. Search spaces of
the hyperparameters used in OntoEA are listed in Table 5. We apply a grid
search strategy for the hyperparameter configuration that performs the best on
the validation set with respect to mean reciprocal rank (MRR).

Table 5: Search spaces of the hyperparameters.

Hyperparameters | Search spaces
---|---
learning rate | {1e-3, 5e-3, 1e-2, 5e-2}
batch size (entity) | {4000, 4500, 5000}
batch size (ontology) | {32, 64, 128}
$\gamma^{1}_{x}$ in Eqs. (1) (2) (4) * | {0.01, 0.02, 0.03}
$\gamma^{2}_{x}$ in Eqs. (1) (2) (4) * | {1.0, 2.0, 3.0}
$\alpha_{x}$ in Eqs. (1) (2) (4) * | {0.1, 0.2, 0.3}
$\lambda_{1}$ in Eq. (6) | {0, 1, 2, 3, 4, 5}
$\lambda_{2}$ in Eq. (6) | {0, 1, 2, 3, 4, 5}
$\lambda_{3}$ in Eq. (6) | {0, 1, 2, 3, 4, 5}
$\beta$ in Eq. (7) | {0.3, 0.4, 0.5, 0.6, 0.7}
|

  * *

where $x\in\\{e,o,m\\}$.

Table 6: Full statistics of all the benchmarks.

Dataset | KG | Ontology b |  Knowledge Graph |  Membership c
---|---|---|---|---
|  | #Cls. | #Sub tr. | #Rel. | #Attr. | #Rel tr. | #Attr tr. | #Links | #Roots
share-O a | EN-FR-15K-V1 | EN | 189 | 755 | 267 | 308 | 47,334 | 73,121 | 15,000 | 639
FR | 210 | 404 | 40,864 | 67,167
EN-FR-15K-V2 | EN | 104 | 755 | 193 | 189 | 96,318 | 66,899 | 15,000 | 533
FR | 166 | 221 | 80,112 | 68,779
EN-DE-15K-V1 | EN | 175 | 755 | 215 | 286 | 47,676 | 83,775 | 15,000 | 155
DE | 131 | 194 | 50,419 | 156,150
EN-DE-15K-V2 | EN | 86 | 755 | 169 | 171 | 84,867 | 81,998 | 15,000 | 165
DE | 96 | 116 | 92,632 | 186,335
MED-BBK-9K | MED | 11 | 10 | 32 | 19 | 158,357 | 11,467 | 9,162 | 86
BBK | 11 | 10 | 20 | 21 | 50,307 | 44,987 | 9,162 | 3,362
not-share-O | D-W-15K-V1 | DB | 172 | 755 | 248 | 342 | 38,265 | 68,258 | 15,000 | 306
WK | 140 | 695 | 269 | 649 | 42,746 | 138,246 | 15,000 | 342
D-W-15K-V2 | DB | 71 | 755 | 167 | 175 | 73,983 | 66,813 | 15,000 | 463
WK | 68 | 695 | 121 | 457 | 83,365 | 175,686 | 15,000 | 418
|  |  |  |  |  |  |  |  |  |

  * a

“share-O” means the to-be-aligned KGs share one ontology while “not-share-O”
means the to-be-aligned KGs have different ontologies.

  * b

“#Cls.” denotes the number of classes and “#Trs.” denotes the number of
rdfs:subClassOf relation triples.

  * c

“#Roots” denotes the number of entities that have no rdf:type property and are
linked to the root class.

##  Appendix C Ontology Alignment Methods

In this section, we present the details of the two ontology alignment methods:
manual annotation and alignment system.

###  C.1 Manual Annotation

We refer to crowdsourcing for manual annotation of the class mappings by the
following steps which are presented with the example of the DBpedia ontology
and the Wikidata ontology in the D-W benchmarks. First, we recruit five
volunteers with at least undergraduate education as the annotators and provide
them the two to-be-aligned ontologies. The DBpedia ontology ($O_{D}$) contains
a total of $755$ classes while the Wikidata ontology ($O_{W}$) contains $695$
classes. Second, for each class in $O_{D}$, denoted as $c_{D}$, each annotator
is required to consider as more classes in $O_{W}$ as possible and find the
equivalent class mapping $(c_{D},c_{W})$, where $c_{W}$ denotes a class in
$O_{W}$. Note that the annotators are allowed to utilize her/his knowledge and
accelerate the annotation by searching for class $c_{W}\in O_{W}$, using some
friendly ontology management and accessing software such as Protégé. After all
five annotators finish the work, only the class mappings that are labelled by
more than three annotators are accepted as the final class mappings, denoted
as $M_{C}$.

With the class mappings, we need to further merge the two ontologies as one
shared ontology which can then be processed by OntoEA. To this end, our
solution is to build new membership relationships between the entities of the
Wikidata KG and the classes of the DBpedia ontology. For each original
membership relationship within the Wikidata KG and ontology, we replace its
class $c_{W}$ with $c_{D}$ if $(c_{D},c_{W})\in M_{C}$, or with the root class
owl:Thing otherwise.

###  C.2 Alignment System

Algorithm 1 Alignment System Method

0: Ontologies $O_{D}$ and $O_{W}$, threshold $\lambda$

1: Build directed graphs $D_{D}$ and $D_{W}$ from $O_{D}$ and $O_{W}$,
respectively, with the relation of rdfs:subClassOf

2: Obtain equivalent class pairs $P_{C}$ from pre-defined owl:equivalentClass
in $O_{D}$ and $O_{W}$

3: Generate $D^{\prime}$ via connecting $D_{D}$ and $D_{W}$ with $P_{C}$

4: Define $\phi(c_{1},c_{2})$ as the length of directed walk from $c_{1}$ to
$c_{2}$ where $c_{1},c_{2}\in D^{\prime}$

5: Initialize empty mapping sets $M_{C}$ and $M^{\prime}_{C}$

6: for each class $c_{W}$ in $O_{W}$ do

7: Route $D^{\prime}$ starting from $c_{W}$ and output routed class set
$S=\\{c\\}$ where $c\in D^{\prime}$

8: if $S=\emptyset$ then

9: Append $(c_{W},$owl:Thing$)$ to $M_{C}$

10: else

11: Find a class $c$ in $S$ such that for any $c^{\prime}$ in $S$
$\phi(c,$owl:Thing$)\geq\phi(c^{\prime},$owl:Thing$)$

12: Append $(c_{W},c)$ to $M_{C}$

13: end if

14: end for

15: Perform PARIS on $O_{D}$ and $O_{W}$

16: Append $M^{\prime}_{C}$ from PARIS with threshold $\lambda$

17: for each class mapping $(c_{w},c_{d})$ in $M_{C}$ do

18: if $(c_{w},c^{\prime}_{d})\in M^{\prime}_{C}$ and $c^{\prime}_{d}\neq
c_{d}$ then

19: Remove $(c_{w},c_{d})$ from $M_{C}$

20: Append $(c_{w},c^{\prime}_{d})$ to $M_{C}$

21: end if

22: end for

23: return $M_{C}$

The automatic method based on the ontology alignment system PARIS and some ad-
hoc pre-processing and post-processing is shown in Algorithm 1. The pre-
processing from Line 1 to Line 13 obtains class mappings via finding the most
fine-grained mappings (i.e., the farthest class node in the directed graph).
Since PARIS generally outputs reliable class mappings, the post-processing
from Line 16 to Line 21 updates class mappings with those output from PARIS.

In the implementation we set PARIS hyperparameter $\lambda$ to $0.4$. The
owl:equivalentClass relationship across the DBpedia ontology and the Wikidata
ontology is acquired via DBpedia and Wikidata SPARQL endpoints. After getting
$M_{C}$, we merge the two ontologies as introduced in the method of manual
annotation.

##  Appendix D More Experimental Results

Table 7: Overall results of OntoEA and the baselines on the EN-DE benchmarks.

Models | EN-DE-15K-V1 |  EN-DE-15K-V2
---|---|---
| H@1 | H@5 | MRR | H@1 | H@5 | MRR
w/o SI | MTransE | .307 | .518 | .407 | .193 | .352 | .274
JAPE | .288 | .512 | .394 | .167 | .329 | .250
SEA | .530 | .718 | .617 | .606 | .779 | .687
GCNAlign | .481 | .679 | .571 | .534 | .717 | .618
BootEA | .675 | .820 | .740 | .833 | .912 | .869
RSN4EA | .587 | .752 | .662 | .791 | .890 | .837
AliNet | .243 | .353 | .295 | .169 | .247 | .277
| OntoEA | .742 | .897 | .812 | .864 | .955 | .905
Improv. best % | 9.9 | 9.4 | 9.7 | 3.7 | 4.7 | 4.1
w/ SI | AttrE | .517 | .687 | .597 | .650 | .816 | .726
MultiKE | .756 | .809 | .782 | .755 | .813 | .784
RDGCN | .830 | .895 | .859 | .833 | .891 | .860
OntoEA | .850 | .906 | .877 | .914 | .977 | .942
Improv. best % | 2.4 | 1.2 | 2.1 | 9.7 | 9.7 | 9.5
|  |  |  |  |  |  |

Table 7 reports the overall results on the cross-lingual benchmarks EN-
DE-15K-V1 and EN-DE-15K-V2. We have similar findings in these two EN-DE
benchmarks as in the EN-FR benchmarks that OntoEA consistently outperform
baselines, w/o SI and w/ SI. On EN-DE-15K-V1, OntoEA generally outperforms
competitive models by up to 9.9% in H@1 and the performance gap is larger in
the models w/o SI than in the models w/ SI. On the dense benchmark (V2),
OntoEA shows limited performance gain (about 4%) compared with the models w/o
SI but much larger performance gain (more than 9%) compared with the models w/
SI.