Ontology matching is the process of generating correspondences between terms of di erent ontologies. Today, several methods for ontology matching have been proposed, which makes di cult the choice of the most suitable to use in a particular setting. In this paper, we propose a novel ontology matching framework that uses automatic matchers recommendation to generate alignments. The di erential of this work is the employment of application requirements as means of acquiring knowledge about a particular matching task.
Ontology matching is the task of nding relationships between entities expressed
in di erent ontologies [
In the last years, many Ontology Matching Systems (Ontology Matchers)
have been proposed, as stated in [
This work introduces a framework for the automatic recommendation of ontology matchers regarding an application-speci c matching task. Existing frameworks typically consider matchers' parameters or reference alignments as input. In this case, the user is engaged mostly only in the later validation of correspondences. A di erential of the proposed framework is that it allows the user to de ne a set of application requirements, which are formalized as RDF resources. The framework aims not only to reduce the search space of a matching task (by producing ontology segments), but also to recommend the most suitable matchers for the reduced setting generated according to the requirements. 2
The integration of ontologies (i.e., establishing a uni ed view of ontologies from heterogeneous sources) has several applications (e.g. data integration, search, and analysis). Ontology matching is an essential step in this process, as sources usually employ di erent terms to describe the same real-world concept, even in the case of sources from the same domain.
Especially in large-scale matching tasks (i.e., when dealing with several ontologies that may contain a lot of elements), it is hard to acquire good quality alignments. It is because of the necessity of more computational e ort (given the high quantity of items to compare), as also a greater number of user validations. As there are several ontology matchers available, the con guration of a matching task may be a complicated and time-consuming task to the user. In this aspect, there is a lack of approaches that could automatically provide the generation of alignments, by using a set of recommended matchers for a particular matching task.
The basic idea of proposed framework is to solve this issue by allowing users to de ne a set of application requirements, enabling both the reduction of the amount of compared terms and the delivery of a set of recommended matchers. Consequently, it also will make easier the con guration of a particular matching task, rather than the need of having knowledge on matchers' characteristics. 3
There are a few works in the literature addressing the ontology matchers
recommendation problem. The work in [
The approaches [
In [
To the best of our knowledge, there are no other work that addresses ontology matchers recommendation by employing application requirements as means of acquiring knowledge about the priorities for a particular ontology matching task. The assumption of using requirements is allowing the user to de ne the relevant terms and the quality metrics to be considered in the matching. We intend to provide both a way to reduce the search space, through the generation of ontology segments related to terms that meet the requirements; and a form to evaluate the matchers more accurately, by considering the metrics that are more signi cant to the user. 4
The following research questions (Q) and related hypothesis (H) investigate how the use of application requirements will reduce the search space of an ontology matching task and consequently improve the matchers' recommendation: { Q1: Would the use of application requirements provide the generation of better ontology segments? Will these segments reduce the search scope of a matching task without loss of quality? { H1: Employing application requirements will enable to generate better ontology segments, reducing more e ciently the search space of a matching task, compared to state of the art techniques. { Q2: How can the use of application requirements improve ontology matchers' recommendations? Is it possible to formalize the application needs regarding an ontology matching task? { H2: Application requirements will allow the users to specify which terms (data requirements) and metrics (quality requirements) should be considered in an ontology matching task. The generation of ontology segments based on the most relevant terms and the use of a set of preferred metrics when evaluating matchers will provide better recommendations, compared to state of the art. RDF resources will be used to formalize the application requirements. 5
The proposed framework aims to support ontology matching users to perform matching tasks using a set of matchers suitable for a particular application. Figure 1 presents the respective framework components and work ow. We introduce a brief example to illustrate the de nition of application requirements and detail the framework work ow in what follows.
To start an ontology matching task, the user should provide a pair of ontologies to match and a set of application requirements. These requirements are represented in the form of RDF statements, given the following two categories: i) Data Requirements and ii) Quality Requirements. The rst are statements describing characteristics of the more relevant terms to be considered in the matching ontologies. These statements are used to generate the ontologies segments. The second ones, are statements that assign weights to quality metrics (e.g. precision, recall, execution time). These weights are used in the evaluation of alignments generated by matchers, resulting in recommendation scores.
To illustrate the de nition of requirements, we introduce an ontology matching scenario. Suppose an application to integrate open data for understanding motivations behind people's migration from one country to another in the last years. Assuming that a large number of data sources may provide diverse data about countries and cities, this would be a typical case when application requirements can be used to specify the scope of a particular ontology matching setting. Table 1 shows the de nition of two data requirements (DR1 and DR2), stating the preference for ontology classes that match with the terms Weather and GDP, in which the latter should have GDP per capta as a subclass. As Quality Requirement (QR), we illustrate the de nition of the weights 0.7 and 0.3 for precision and execution time respectively, assuming that the application intends to reduce the number of generated correspondences and the execution time, given a large number of sources that may be considered. The framework work ow starts by receiving a set of ontologies and application requirements from the user. Then, the following steps are performed: i) ontology segment generation; ii) related alignments nding; iii) matchers score calculation, iv) matchers execution and iv) alignments validation. Furthermore, as a support for these steps, the framework also uses an already established knowledge base containing ontologies, matchers, alignments and validations acquired from reliable sources (e.g. OAEI).
Ontology Segment Generation. The rst step is the generation of ontology segments following the data requirements provided, which will result in a reduced subset of ontologies containing only the most relevant terms for the user. The segment generation is made by traversing the ontologies structure searching for terms that meet the requirements. Ontology segments are automatically generated based on these terms and their correspondent elements (e.g. classes, subclasses, superclasses), depending on the data requirements.
Related Alignments Finding. The second step is seeking for related alignments (in the alignment database), i.e., the ones between ontologies that share similar characteristics with the generated segments. To de ne this similarity, we assign some values to ontologies (or segments) regarding the following matchers types: i) syntactic, ii) lexical; iii) structural and iv) instance-based. Matcher Score Calculation. The third step is to calculate a score for the available matchers considering the results of alignments evaluations, following the weights for each metric de ned in the quality requirements. The list of matchers ordered by score will compound the matchers ranking for the current setting. Matchers Execution. Once the ranking of recommended matchers was established, the user can apply some criteria (e.g. minimum score threshold or maximum matchers quantity) to select matchers and then perform their execution, regarding the following steps: pre-matching, matching, combination, and ltering.
Alignment Validation. In the nal step, the user can provide some feedback about alignments provided by the framework. For this, it is possible to walk through the alignments' correspondences and annotate them with positive or negative statements. This information is also stored in the Validations Database and may impact on subsequent interactions.
Knowledge Bases. The knowledge bases store information about ontologies,
matchers, alignments and validations, serving as a baseline to the mentioned
steps. Regardless of what is the current step in the work ow, the user can provide
data to the knowledge base aiming to improve the obtained results. The
Ontologies Database includes basic descriptions, such as URI and format (e.g. RDF,
OWL). The Matchers Database stores some metadata about existing matchers,
such as name, version, main features and service endpoint. In the Alignments
Database, following as a standard the Alignment API [
To evaluate the proposed framework, we perform experiments with real matchers on public datasets. The initial tests targeted the datasets provided by OAEI tracks (e.g. conference, anatomy). For this, we rst have prepared the knowledge bases, by adding some metadata about reference ontologies, existing matchers (preferably OAEI participants) and alignments evaluations (when reference alignments are available). As further experiments, we also plan to test the framework in other domains, such as the integration of ontologies from open data repositories. Our hypothesis will be validated if the experiments demonstrate that the use of application requirements enables the reduction of a matching task and consequently the recommendation of the best matching systems.
To obtain some preliminary results, we have developed a prototype of the
proposed framework. For initializing the Ontology Database, we have imported some
ontologies from the OAEI Conference and Anatomy datasets (Cmt, Conference,
ConfOf, Edas, Ekaw, Iasted, Sigkdd, Human, and Mouse). To ll the Matchers
Database, we have considered the ones that usually are participants in OAEI
campaigns and that have a publicly available source code. To standardize the
access (input/output), we have implemented a wrapper for each matcher. In the
initial experiment, we considered the matchers COMA [
Quality Metrics
Execution Time (seconds) 0,9 0,8 0,7 0,6 0,5 0,4 0,3 0,2 0,1 0
COMA COMA AML AML LogMap LogMapFCAMapFCAMap YAM YAM (seg) (seg) (seg) (seg) (seg)
Precision Recall F-measure 0 5 10 15 20
25 YAM (seg)
YAM FCAMap (seg)
FCAMap LogMap (seg)
LogMap AML (seg)
AML COMA (seg)
COMA In this work, we present a framework for matchers recommendation based on application requirements. Even though the preliminary results indicate that the proposed approach is promising, we now are focused on performing further experiments to obtain more extensive results. We still have some work on design and implementation of the framework, but the main structure was implemented in the initial prototype, which will support the execution of new experiments.
We expect that the proposed framework can bring as main contributions: i) the ease of preparation of a matching task, by using requirements instead of matcher-speci c parameters; and ii) the generation of alignments with better quality, by reducing the matching search space and by using the best recommended matchers to generate alignments. Another bene t of this framework would be the reduction of execution time, since the matching will not be performed on entire ontologies, but only on the more relevant segments to the user. Acknowledgments. I am grateful to my advisor Dr. Ana Carolina Salgado and my co-advisor Dr. Bernadette Farias Loscio for their support and the opportunity for the realization of this work.