A foundation for ontology modularisation

There has been great interest in realising the Semantic Web. Ontologies are used to define Semantic Web applications. Ontologies have grown to be large and complex to the point where it causes cognitive overload for humans, in understanding and maintaining, and for machines, in processing and reasoning. Furthermore, building ontologies from scratch is time-consuming and not always necessary. Prospective ontology developers could consider using existing ontologies that are of good quality. However, an entire large ontology is not always required for a particular application, but a subset of the knowledge may be relevant. Modularity deals with simplifying an ontology for a particular context or by structure into smaller ontologies, thereby preserving the contextual knowledge. There are a number of benefits in modularising an ontology including simplified maintenance and machine processing, as well as collaborative efforts whereby work can be shared among experts. Modularity has been successfully applied to a number of different ontologies to improve usability and assist with complexity. However, problems exist for modularity that have not been satisfactorily addressed. Currently, modularity tools generate large modules that do not exclusively represent the context. Partitioning tools, which ought to generate disjoint modules, sometimes create overlapping modules. These problems arise from a number of issues: different module types have not been clearly characterised, it is unclear what the properties of a 'good' module are, and it is unclear which evaluation criteria applies to specific module types. In order to successfully solve the problem, a number of theoretical aspects have to be investigated. It is important to determine which ontology module types are the most widely-used and to characterise each such type by distinguishing properties. One must identify properties that a 'good' or 'usable' module meets. In this thesis, we investigate these problems with modularity systematically. We begin by identifying dimensions for modularity to define its foundation: use-case, technique, type, property, and evaluation metric. Each dimension is populated with sub-dimensions as fine-grained values. The dimensions are used to create an empirically-based framework for modularity by classifying a set of ontologies with them, which results in dependencies among the dimensions. The formal framework can be used to guide the user in modularising an ontology and as a starting point in the modularisation process. To solve the problem with module quality, new and existing metrics were implemented into a novel tool TOMM, and an experimental evaluation with a set of modules was performed resulting in dependencies between the metrics and module types. These dependencies can be used to determine whether a module is of good quality. For the issue with existing modularity techniques, we created five new algorithms to improve the current tools and techniques and experimentally evaluate them. The algorithms of the tool, NOMSA, performs as well as other tools for most performance criteria. For NOMSA's generated modules, two of its algorithms' generated modules are good quality when compared to the expected dependencies of the framework. The remaining three algorithms' modules correspond to some of the expected values for the metrics for the ontology set in question. The success of solving the problems with modularity resulted in a formal foundation for modularity which comprises: an exhaustive set of modularity dimensions with dependencies between them, a framework for guiding the modularisation process and annotating module, a way to measure the quality of modules using the novel TOMM tool which has new and existing evaluation metrics, the SUGOI tool for module management that has been investigated for module interchangeability, and an implementation of new algorithms to fill in the gaps of insufficient tools and techniques

Co-creation in service assemblages for service innovation : an empirical investigation

Co-creation could enhance service innovation (Perks, Gruber, and Edvardsson, 2012). Despite the research conducted on co-creation, the issue concerning how actors could form service system with high density still needs to be addressed (Michel, Vargo and Lusch, 2008). We conceptualized service system as an assemblage and investigated emergence and dynamic process of assemble and dissemble of service assemblages by drawing on theories of co-creation, affordance, task network and modularity and the notion of assemblage (Delanda, 2006). We developed a framework and empirically examined how to map the competences required for actors in a task network and how capacities could be optimally (re)configured as assemblages (clusters) for value co-creation. We demonstrated that the framework developed could be applied to formation, reformation of service assemblages for design of service offerings enabling optimal value co-creation

NOMSA: Automated modularisation for abstraction modules

Large and complex ontologies lead to difficulty in usage by humans and causes processing problems with software agents. Modularity has been proposed to address this problem. Current methods and tools can be used to create only some of the existing types of required modules. To augment options for modularisation, we present novel methods to create ve types of abstraction modules: axiom abstraction, vocabulary abstraction, high-level abstraction, weighted abstraction, and feature expressiveness. They have been implemented in the novel tool NOMSA for automated modularisation, which also offers a GUI

Structuring Abstraction to Achieve Ontology Modularisation

Large and complex ontologies lead to usage difficulties, thereby hampering the ontology developers’ tasks. Ontology modules have been proposed as a possible solution, which is supported by some algorithms and tools. However, the majority of types of modules, including those based on abstraction, still rely on manual methods for modularisation. Toward filling this gap in modularisation techniques, we systematised abstractions and selected five types of abstractions relevant for modularisation for which we created novel algorithms, implemented them, and wrapped it in a GUI, called NOMSA, to facilitate their use by ontology developers. The algorithms were evaluated quantitatively by assessing the quality of the generated modules. The quality of a module is measured by comparing it to the benchmark metrics from an existing framework for ontology modularisation. The results show that module’s quality ranges between average to good, whilst also eliminating manual intervention

MODDALS Methodology for Designing Layered Ontology Structures

Global ontologies include common vocabularies to provide interoperability among different applications. These ontologies require a balance of reusability-usability to minimise the ontology reuse effort in different applications. To achieve such a balance, reusable and usable ontology design methodologies provide guidelines to design and develop layered ontology networks. Layered ontology networks classify into different abstraction layers the domain knowledge relevant to many applications (common domain knowledge) and the domain knowledge relevant only to certain application types (variant domain knowledge). This knowledge classification is performed from scratch by domain experts and ontology engineers. This process is a heavy workload, making it difficult to design the layered structures of reusable and usable global ontologies. Considering how common and variant software features are classified when designing Software Product Lines (SPLs), we argue that SPL engineering techniques can facilitate the domain knowledge classification taking as reference existing ontologies. This paper presents a methodology that provides guidelines to design the layered structure of reusable and usable ontology networks called MODDALS. In contrast to previous methods, MODDALS applies SPL engineering techniques to systematically (1) identify the ontology common and variant domain knowledge and (2) classify it into different abstraction layers taking as reference existing ontologies. This approach complements domain experts’ and ontology engineers’ expertise, preventing them from classifying the domain knowledge from scratch facilitating the design of the layered ontology structure. MODDALS methodology is evaluated in the design of the layered structure of a reusable and usable global ontology for the energy domain. The results show that MODDALS enables to classify the domain knowledge taking as reference existing ontologies

Dependencies between modularity metrics towards improved modules

Recent years have seen many advances in ontology modularisation. This has made it difficult to determine whether a module is actually a good module; it is unclear which metrics should be considered. The few existing works on evaluation metrics focus on only some metrics that suit the modularisation technique, and there is not always a quantitative approach to calculate them. Overall, the metrics are not comprehensive enough to apply to a variety of modules and it is unclear which metrics fare well with particular types of ontology modules. To address this, we create a comprehensive list of module evaluation metrics with quantitative measures. These measures were implemented in the new Tool for Ontology Module Metrics (TOMM) which was then used in a testbed to test these metrics with existing modules. The results obtained, in turn, uncovered which metrics fare well with which module types, i.e., which metrics need to be measured to determine whether a module of some type is a ‘good’ module

An empirically-based framework for ontology modularization

Modularity is being increasingly used as an approach to solve for the information overload problem in ontologies. It eases cognitive complexity for humans, and computational complexity for machines. The current literature for modularity focuses mainly on techniques, tools, and on evaluation metrics. However, ontology developers still face difficulty in selecting the correct technique for specific applications and the current tools for modularity are not sufficient. These issues stem from a lack of theory about the modularisation process. To solve this problem, several researchers propose a framework for modularity, but alas, this has not been realised, up until now. In this article, we survey the existing literature to identify and populate dimensions of modules, experimentally evaluate and characterise 189 existing modules, and create a framework for modularity based on these results. The framework guides the ontology developer throughout the modularisation process. We evaluate the framework with a use-case for the Symptom ontology