System of systems (SoS) are interconnected systems that bring value to different domains like health, emergency and crisis management systems. The integration of these SoS creates opportunities to change, validate the information, and add more value to information systems. SoS may have ontologies in their background to support knowledge description and semantic integration. Consequently, the integration of SoSs may benefit from the integration of the network of ontologies behind. However, the task of integrating networks of ontologies, especially the ones describing real-world SoS can be infeasible due to the size of the networks. In this work, we propose an approach, SubInterNM, based on algebraic operations that reduces the number of comparisons needed to match the networks behind the SoSs. We validated our approach using networks of ontologies created from the OAEI ontologies. The SubInterNM combined with Alin and LogMap can overcome these matchers, when running alone in some cases.
A System-of-Systems (SoS) is defined as a set of independent systems, providing
functionalities derived from the interoperability among them [
A network of ontologies (NO) is a set of two or more aligned ontologies. The
network can represent a set of domains of their compound ontologies. Each ontology
describes the knowledge of a domain of interest [
In current scenarios demanding data integration and systems interoperability (such as company acquisitions) within the same business domain, different SoS must be integrated. Because of the intrinsically multiple possible relationships inside the SoS that includes IS from distinct companies, the integration can be challenging and may be viewed as a matching of ontologies networks, requiring mapping concepts between both SoSs. This research addresses how to match a network of ontologies.
This study proposes an approach to optimize internetwork matching in the context
of networks of ontologies, by systematically examining the characteristics of the NO
and avoiding computing all possible matchings between entities. More specifically, we
implement the subsumed internetwork matching (SubInterNM) [
This work addresses the following research question: ”Is it possible to align two ontology networks without computing all the possible alignments, with viable computational effort, time and precision, recall and f-measure?”. To answer this question, this paper contributes by proposing an approach to match network of ontologies and its implementation into a prototype tool, as well as an empirical study showing the viability of the approach and its performance gains over state-of-the-art matching tools.
This work is organized as follows: in section 2, we summarize background. Evaluation results and a discussion are presented in section 3. Section 4 describes the limitations, and finally, section 5 concludes and points to future work. 2
Current approaches for ontology matching include pairwise matching [
The ontology matching problem is not new and has been researched for a decade.
However, to our knowledge, the matching of Network of Ontologies has not received
the same attention. Although there are few studies dealing with networks of ontologies
and, consequently, matching networks, there are still open challenges [
To assess SubInterNM we conducted an experiment using ontologies from the OAEI conference domain, so as to limit the size and help checking the results manually.
We selected Alin [
We first selected ontologies to compose two networks of ontologies. Since LogMap and Alin are not able to natively process networks, the baseline submitted as input to bhttps://github.com/fabiojavamarcos/interNetworkOntologyMatching czenodo.org (10.5281/zenodo.3977855) these matchers consisted of the union of all ontologies from each network. The alternative scenario to be compared consisted of executing SubInterNM and then submitting its partial results to the LogMap and Alin matchers. Following, each possible pair of ontologies was submitted to LogMap and Alin alone, with duplication and without duplication (when pairs of the same ontologies were manually eliminated, i.e. Edas x Ekaw and Ekaw x Edas; Edas x Edas). For each scenario we collected the following metrics: processing time, average precision, average recall, and average f-measure. – 2x2: = fsigkdd, confofg and 0 = fconference, confofg; – 4x4: = fsigkdd, confof, ekaw, edas g and 0 = fconference, confof, ekaw, edasg; – 5x5: = fsigkdd, confof, ekaw, edas, iasted g and 0 = fconference, confof, ekaw, edas, iastedg; – 5x1: = fsigkdd, confof, ekaw, edas, iastedg and 0 = fconferenceg; – 5x2: = fsigkdd, confof, ekaw, edas, iasted g and 0 = fconference, confofg; – 5x3: = fsigkdd, confof, ekaw, edas, iastedg and 0 = fconference, confof, ekawg;
The results show higher precision, recall, and f-measure using the SubInterNM combined with the Alin compared with the matcher alone and when combined with LogMap (Table 1). LogMap combined with SubInterNM or alone was faster than SubInterNm+Alin or Alin alone, even when the network size grew (Table 2).
The metrics (Table 1) showed a decrease in the values of the Alin and LogMap approach as the network grew. It can be explained by the lack of flexibility of the solutions in understanding a reference alignment that contains concepts coming from different ontologies. It occurs because when finishing the union operation, the resulting temporary ontology is composed of the union of concepts from all the ontologies together. LogMap handled better than complexity and loosed significantly less precision than Alin. The experiments using the matcher alone started aligning the structure after the union to standardize the input for all approaches.
In Table 3, we ran the matcher in all possible combinations, Oi x Oj , (column ”All”) or without duplications (column ”Time”). We computed the sum of processing time and the average of the quality metrics. Alin obtained higher quality metrics again, while LogMap continued to be faster. Looking at the 5x5 and 5x1 cases, we observe that Alin used significantly more time than when combined with the SubInterNM, but delivered better quality metrics. LogMap outperformed all the options wrt processing time and obtained similar metrics in the 5x5 case and better ones in the 5x1 case.
Examining the column ”All” (Table 3), we observe that LogMap processing times were comparable to SubInterNM + LogMap, but the latter approach produced a result without duplicated alignments. Alin alone had better results than SubInterNM + Alin but used significantly more time and delivered solutions with duplications and may cost more O(nlogn) effort and more time. In networks with many isomorphisms, the SubInterNM + Alin delivered more balanced results combining metrics and time processing. On the other hand, classic pairwise approaches have better outcomes when the networks had few isomorphisms.
Finally, it is possible to avoid the Cartesian product and keep processing time and resulting metrics depending on the characteristics of the networks being aligned. When pruning the Network of Ontologies to reduce the posterior matcher computations, some entities can be missing. This may impact on how the similarity algorithms find the alignments, which may lead to different results. The use of a dataset from the same domain is not a real scenario, as discussed in Section 1. Yet, this enabled us to manually verify the algebraic operations and the computed metrics, since we needed many customized reference alignments.
Because of the many possibilities in the experiments, we needed to create some new reference alignments based on the existing from OAEI. These were validated by the research group but are not error-proof.
Finally, the intrinsic characteristics of the ontologies considered in the experiment generated sparse graphs, which may have helped the algebraic algorithms. In scenarios with more dense ontologies (i.e., with more connections among their concepts), we could have strongly connected graphs and, consequently, worse time processing when using our proposed SubInterNM. 5
This paper contributes by presenting a novel concept of a Network of Ontologies Matcher approach.The proposal was implemented in a prototype to show its feasibility and confirm (our research question) that it is possible to align two ontology networks without computing all the possible alignments, with viable computational effort, time and precision, recall and f-measure. As predicted, the experiment results confirmed that SubInterNM computed the matching among distinct networks of ontologies more efficiently than using the traditional pairwise approach in specific cases, due to avoiding unnecessary comparisons without losing information.
For future work, we aim to run experiments with larger ontologies and networks,
discover the optimal point where the SubInterNM can be used and add a strategy to
retracting/forgetting axioms/entities [