Conceptual data modelling languages are a common approach to represent ontologies visually. This paper introduces a framework aiming at enabling modelling tools to represent, manipulate and reason over OWL ontologies represented in different visual languages, such as UML, EER or ORM 2, based on a previously developed theoretical metamodel. We describe the framework and define a methodology to exploit it, in order to make visual independence a reality. Finally, we present case studies on realistic ontologies to show the applicability of our approach.
Aiming to put together these related aspects, we have previously identified the
following set of system requirements framed into a web architecture for visual ontology
engineering tasks, named crowd1 [
In summary, suitable visualisations, automated reasoning and metamodelling are
key features in ontology engineering to facilitate the analysis and design of models and
successfully integrate modeller’s intentions with the formal semantics. With this work,
we go one step further towards satisfying these requirements. Our main contributions are:
1. the development of a framework that integrates visual editing over EER, UML and
ORM 2 conceptual modelling languages, which covers R4 and R5 requirements.
This capability is based on the solid theoretical background of the KF metamodel.
Here, we implement the subset of interoperability rules, given by KF, which
unifies the commonalities of the selected CDM languages.
2. the development of a new interface for partial visualisation of OWL ontologies in
any of the supported notations, by mapping OWL axioms to KF, integrated on the
framework. This feature aims to assist people who are not familiar with OWL but
are familiar with some other notation such as UML, EER, or ORM 2.
3. the design of a new version of crowd core implementing the encoding of KF
metamodel instances as DL knowledge bases, which satisfies the R3 requirement.
4. a methodology, where we exploit visualisation, metamodelling and reasoning for
dealing with ontology development tasks. The methodology makes use of custom
visualisations but keeping only one common and unified model. It enables
representing ontologies by using different visual representations, and hence,
manipulating simultaneously these representations. Finally, we also show how this could
be used to partially visualise arbitrary OWL 2 ontologies [
This work is structured as follows. Section 2 reviews some preliminary concepts related to the KF metamodel and the tool crowd. Section 3 presents and details the proposed framework together with the methodology to exploit it. Section 4 shows case study based on a realistic ontology. Finally, section 5 details related approaches, and section 6 concludes the work and presents future directions.
In this section, we briefly describe the preliminary concepts of our work. We give descriptions of both the Keet-Fillottrani (KF) metamodel and crowd, which is a web tool for ontology development tasks.
The intention behind the ontology-driven KF metamodel [
The KF metamodel defines four groups of interoperability rules
[
ORM 2 visual
editors Input/Output crowd ORM2
Norma EER visual
editors Input/Output crowd EER other editor other editor
UML Interface KF API
KF Metamodel OWL2KF OWLAPI
Responses «artifact»
DL Reasoner crowd UML ORM2 Interface EER Interface OWL2 Interface
UML visual editors
Input/Output «uses» «framework» crowd
«uses»
KF Interface «uses» «uses»
«uses» «uses» crowd core
DL Translator
Ontology Editors Input/Output
Protégé other tool
crowd [
The leverage of automated reasoning is enabled by a precise semantic definition of all the elements of the diagrams. Hence, diagrams constraints are internally translated into a logic-based formalism capturing typical features of models. The tool is fully integrated with a powerful logic-based reasoning server acting as a background inference engine. Unlike other tools, crowd is based on a deduction-complete notion of reasoning support relative to the diagram graphical syntax. Thus, users will see the original model graphically completed with all the deductions and expressed in the graphical language itself. This includes checking class and relationship consistency, discovering implied class and cardinality constraints. First versions of crowd only focus on visual modelling of schemes, while it does not consider individuals yet.
Currently, crowd enables ontology development tasks by using UML diagrams and supporting automated reasoning over them. Furthermore, it presents Semantic Web Compatibility, the tool ensures compliance with W3C standards by allowing defining global naming schemes as well as exporting specifications OWL 2 to interoperate with other tools.
In this section, we describe the main components of our new framework. We first present its architecture, where both the KF metamodel and the new crowd core are integrated. Finally, we explain the methodology underlying to our approach and show the capabilities of the framework in a behavioural model. The suite of tools involved in this framework is composed of a core PHP, two visual tools for both UML and ORM 2 diagrams and two Java APIs. All of the tools are open source and are available at: https://bitbucket.org/gilia/workspace/projects/CROW.
Figure 1 depicts the module view style of the proposed architecture. The A <<uses>>
B relationship defines the interaction between modules. Each module provides a set of
responsibilities aiming to define the role of such a module in achieving certain functionality.
This view details how these units ensemble to form one greater structure. The framework
is structured as follows.
(i) The external visual editors for UML, EER and ORM 2. Each one interacts with the
framework by sending the diagrams using the HTTP protocol. Currently, only the UML
and ORM 2 editors provided by crowd have been integrated to the framework, however,
other applications dealing with conceptual modelling languages for ontology development
communicate with the core by giving their models to the respective interfaces.
(ii) The interfaces are the entry points to the framework. They process the inputs and
outputs according to the schemes accepted by the KF interface. From the
implementation point of view, these schemes are JSON objects with the primitives of the
visual models. Aiming at using crowd to import OWL 2 ontologies, the framework
includes an OWL 2 interface which differs from the other ones. In particular, it only
loads an OWL document, which is after parsed and manipulated by the OWL API
[
All of these modules are orchestrated by the KF Interface, which receives the external inputs and redirect them to the remaining modules according to the requirements from users.
Our methodology exploits visualisation, metamodelling and reasoning for dealing with ontology development tasks. In particular, it enables custom visualisations but keeping only one common and unified model. Figure 2 illustrates an OCBC model with the flow Load OWL 2
Load UML/EER/ORM2 1
1
Generate KF Metamodel 1 1 creates X Encoding to OWL 2 1
instantiates 1 1
KF Instance 1is_encode1d..* SpeOciWficLation 1 refers to
DL Reasoning
1 modifies updates
Export UML/EER/ORM2 of tasks in our framework. Here we show the interaction between these tasks (in blue) and between the underlying data model (in orange). We consider the below scenarios. (i) In the first scenario, users draw a scheme using any of the CDML supported, which is automatically mapped to the KF metamodel and thus generating the respective instance (applying the metamodel interoperability rules): Load UML/EER/ORM2 ! Generate KF Metamodel. According to the users’ choice, this instance could be exported again to other CDML: Generate KF Metamodel ! Export UML/EER/ORM2; or encoded into OWL 2 to be checked. In the latter case, the metamodel instance could or not be updated with the reasoning results before being exported and visualised in one of the CDML supported: Generate KF Metamodel ! Encoding to OWL 2 ! DL Reasoning ! Update KF Metamodel ! Export UML/EER/ORM2. (ii) In the second scenario, users load an OWL document, which is automatically mapped to the KF metamodel and thus generating the respective instance: Load OWL 2 ! Generate KF Metamodel. Here, the KF instances are generated by mapping OWL axioms to KF entities, previously parsed by the OWL API. Once the KF instance has been generated, the only possible task to be executed is to export it to one of the CDML supported: Generate KF Metamodel ! Export UML/EER/ORM2. The crossed line between Load OWL 2 and Encoding to OWL 2 indicates that if Load OWL 2 is executed then Encoding to OWL 2 is never executed.
As far as we are aware, there is not any exact match between arbitrary OWL
2 ontologies and the KF metamodel [
UML to KF
(R1) Association =======) Relationship
in: Association(AssociationEnd: Class, AssociationEnd : Class)
out: AssociationEnd ! Role
out: Association ! Relationship
out: Class ! Object Type
out: Relationship(Role:Object Type, Role:Object Type)
(1)
(2)
(3)
(4)
(5)
from [
So let us suppose that an ontology defines the hasLocation object property, whose domain and range are BioEvent and Location, respectively. Thus, the (R1) input is hasLocation(AssociationEnd: BioEvent, AssociationEnd: Location) (Figure 3, (1)). Following the rule structure, we should map the object property as a metamodel relationship hasLocation (Figure 3 (3)). As we said, the definition of a relationship requires of other associated primitives: Role and Object Type. Thus, both object property domain BioEvent and range Location can be mapped to Object Type (Figure 3 (4)), however, two fresh roles, bioEventRole: Role and locationRole: Role must be created to complete the definition of such relationship and instantiate (Figure 3 (2)). Therefore, adding those fresh roles implies that a new OWL 2 specification, different from the first one imported, could be generated.
BiGe-Onto [
Figure 4 depicts the current model of BiGe-Onto, which has been modelled in crowd-UML. There, we can identify each ontology reused to build it. The corresponding URIs of namespaces have been also loaded in the tool. Concepts extracted from Darwin Core vocabulary models events, where occurrences referencing organisms have been identified along with their respective locations and regions. On the same hand, the information related to these locations and regions are modelled by reusing concepts from GeoSPARQL and ENVO. Finally, events have date and time descriptions given by Time ontology, and datasets and persons by VoID and FOAF, respectively. This model has been used to guide the process of mapping the raw data to RDF. Further information about the case study, such as demos and images, can be found at http://crowd.fi.uncoma.edu.ar/ontobras/.
Our first case study is about applying interoperability rules to convert an initial UML model of BiGe-Onto into an ORM 2 model. This scenario involves running the following tasks depicted in the Figure 2: Load UML, Instantiate KF Metamodel, and
ENVO
GeoSPARQLFOAF Darwin Core Export ORM 2. Both the first and the last tasks are depicted in Figure 4 and Figure 5, respectively. The crucial task here is to instantiate the KF metamodel, which imply to apply its interoperability rules.
As can be seen from Figure 4, the model contains 18 classes, 7 generalisations, 11 associations (with their respective roles), and 6 attributes distributed between the classes MeasurementOrFact and Geometry. Using the 1:1 Mapping rule we can generate the following entities: 18 Object Type, 11 Relationship, 22 Role, 7 Subsumption, and 22 Object type cardinality, making a total of 80 rules applied to generate our instance. To illustrate it, below we show the case of Relationships(R) rule. For the example, we use the classes Environment, Region, and the association characterizes from the BiGe-Onto model in Figure 4. (R) UML to KF characterizes : Association ! characterizes : Relationship environmentEnd ! environmentRole : Role
regionEnd ! regionRole : Role characterizes ! characterizes : Relationship
environmentEndM ult : M ultiplicity ! environmentEndMult : OTCardinality2
regionEndM ult : M ultiplicity ! regionEndMult : OTCardinality2 0 ! 0 : MinOTCardinality 0 ! 0 : MinOTCardinality
(R) KF to ORM 2 characterizes : Relationship ! characterizes : F actT ype environmentEnd ! environmentRole : Role
regionEnd ! regionRole : Role characterizes ! characterizes : F actT ype
Environment ! Environment : ObjectT ype
Region ! Region : ObjectT ype environmentEndCard : Cardinality ! environmentEndCard : OT Cardinality2 0 ! 0 : M inOT Cardinality
N ! N : M axOT Cardinality regionEndCard : Cardinality ! regionEndCard : OT Cardinality2 0 ! 0 : M inOT Cardinality
N ! N : M axOT Cardinality Once the KF metamodel has been instantiated, the next step in the conversion process is the application of interoperability rules to generate an ORM 2 model from the KF metamodel instance. The conversion from the metamodel to ORM 2, using 1:1 Mapping rules, will generate an equal amount of entities as the metamodel instance but using ORM 2 primitive names.
In addition, to provide customisable visualisations from the utilisation of a unified model, we want to add support for automated reasoning over such common instance. This scenario corresponds to the flow Load UML ! Generate KF Metamodel ! Encoding to OWL 2 ! DL Reasoning ! Update KF Metamodel ! Export UML defined for our methodology. In particular, it involves encoding each metamodel instance as an OWL specification, and thus to be sent to off-the-shelf DL reasoners for checking for satisfiability and discovering (possible) implicit assertions.
Considering again our initial BiGe-Onto model and the OWL formalisation of the whole metamodel3, we consider the DL semantics of UML generalisations and an association of BiGe-Onto as shown below. (S) KF to DL DL
(Feature; SpatialObject) : Subsumption ! (F eature; SpatialObject) : SubClassOf (Geometry; SpatialObject) : Subsumption ! (Geometry; SpatialObject) : SubClassOf
F eature v SpatialObject
Geometry v SpatialObject The first mapping (S) KF to DL takes the metamodel instance generated from UML composed generalisation between the SpatialObject, Feature and Geometry. Such instance generates two Subsumption primitives and the respective Object Types. In DL, we simply write two concept inclusion between these atomic concepts.
There exist many ways to express requirements and test ontologies to understand the
content of them [
We describe the case of extending BiGe-Onto by re-using entities from FaBiO4
ontology [
f abio : Expression a owl : Class f abio : LectureN otes a owl : Class rdf s : subClassOf f abio : Expression
f abio : Chapter a owl : Class rdf s : subClassOf f abio : Expression
f abio : Expression ! Expression : ObjectType f abio : LectureN otes ! LectureNotes : ObjectType LectureN otes:subClassOf : Expression ! playSub : Role f abio : Expression ! playSup : Role
f abio : Chapter ! Chapter : ObjectType Chapter:subClassOf : Expression ! playSub : Role
f abio : Expression ! playSup : Role
As the OWL 2 to KF rule shows, OWL 2 classes are mapped to Object Type, while both LectureNotes and Chapter play the subclass role and Expression plays superclass role. Once a KF instance has been generated containing all the subsumptions, we could follow the flow to export this instance into an appropriate visual language.
Several approaches have been proposed to address formalisation and implementation
of suitable tools for ontology engineering tasks, that integrate visual multi-model,
conversion among different CDMLs and automated reasoning. One of such works is
presented in [
Going one step further, an Universal Conceptual Modelling (UCM) Framework
is proposed in [
GeRoMe [
Finally, two commertial visual tools have been considered:
We have shown the feasibility of using a unified model to implement visual independence in an ontology engineering tool by leveraging the theoretical KF metamodel and automated reasoning. To this end, we have provided a framework that integrates visual editing over EER, UML and ORM 2 conceptual modelling languages, along with a methodology to exploit it. Finally, we have demonstrated the applicability of our approach by introducing case studies on a realistic ontology.
The central aspect of the methodology is based on manipulating metamodel instances, which can be exported as visual models in diverse conceptual data modelling languages or mapped to OWL 2 to reason over them. Thus, separating the visual abstraction from the formal one. Through the case studies, we have analysed diverse scenarios where visualisation, metamodelling and reasoning are required. However, they also brought to light new challenges. In particular, those related to the interoperability with arbitrary OWL 2 ontologies and the scalability of the whole approach.
In conclusion, we foresee various future to improve the results obtained here. On one side, the obvious one is to continue the implementation of more interoperability rules. On the other hand, we plan to extend the compatibility of OWL 2 and the KF for dealing with arbitrary OWL 2 ontologies. http://astah.net/features/
KF metamodel formalization.
CoRR,