Navigation in Large Ontologies

Transcription

1 Navigation in Large Ontologies Aamna Qamar 1 1 The University of Manchester, Oxford Rd, Manchester M13 9PL, UK Abstract. The ever-growing data on the Web has given rise to ontologies reaching the size of 100,000s concept names. The tools available to manipulate and navigate in ontologies are not competent enough to handle such large ontologies. This paper discusses a new tool prototype that allows the ontology engineers to easily perform navigation and exploration tasks in large ontologies for their sense-making. The navigation tasks, like ontology summary, focusing and zooming can be achieved through search functionality that can be run with or without reasoner. For filtering and extracting modules, the syntactic-locality modularization tools are also incorporated in the prototype. The evaluations presented in this paper demonstrate the significantly positive results obtained by experimentation with real-world large ontologies on this tool. Keywords: Ontologies, key concepts extraction, ontology engineering, Web Ontology Language (OWL), modularization, ontology navigation. 1 Introduction Ontologies are frameworks for organization of terminological information and specification of shared conceptualization [1, 2]. Like thesauri, ontologies are used to define the meaning of concepts, describe their properties and express the interrelationships between these concepts. They are used in a range of fields like Artificial Intelligence, Systems Engineering, Knowledge Management etc. Various sophisticated editors and visualization tools exist for navigating through the ontologies such as Protégé 1, OWL API 2 [3], NeOn Toolkit 3 etc. Usually ontologies perform quite well, providing efficient results for querying information. Unfortunately, the problem arises as the size of the ontologies starts reaching the likes of 100,000s of concepts [4]. Navigation facilities in large ontologies still require research attention and improved methods. This paper presents the development of an efficient navigation tool for such large ontologies. The paper is organized as follows. Section 2 covers the discussion on ontologies, and Web Ontology Language (OWL). The performance of existing tools for large ontologies is studied in Section 3. Section 4 explains the development approach for the prototype. Section 5 discusses the evaluation results. Finally, conclusion and future work are given in Section last accessed 2017/04/ last accessed 2017/04/ last accessed 2017/04/26

2 2 2 Ontologies and Web Ontology Language (OWL) 2.1 Overview of Ontologies The literature refers to ontologies in a variety of ways, but the most commonly used definition was given by Gruber [1], quoted as an explicit specification of a conceptualization. With the popularity of usage of ontologies, came the need to share the knowledge represented in these ontologies. Therefore, this definition was further elaborated by Borst et al. [2] as a formal specification of a shared conceptualization. Mathematically, ontologies can be defined as a triple [6]: O = (setofclasses, setof Roles, setof Relationships) According to Hitzler et al. [5], the Knowledge Representation (KR) revolves around the fundamental notions of axioms, entities and expressions. Most of the ontologies are also designed upon this fundamental architecture and have a common underlying structure irrespective of the language they are expressed in. The chief components of ontologies [7] include classes, individuals, attributes, relations, function terms, restrictions and rules. 2.2 Web Ontology Language (OWL) Web Ontology Language (OWL) is a family of Description Logic based Knowledge Representation languages developed for encoding ontologies [5]. Its increasingly expressive sublanguages are OWL Lite, OWL DL and OWL Full [8]. OWL 2 is an extension of the OWL language defined as a computational logicbased language such that knowledge expressed in it can be reasoned with by computer programs [5]. The structure of OWL 2 comprises of two layers around the ontology namely syntax and semantics layers. The syntaxes include RDF/XML [9], OWL/XML [10], Functional [11], Manchester [12] and Turtle [13]. Semantic specifications are used to define the meaning and derive interpretations of OWL ontologies and comprise of Direct and RDF-based semantics [14]. OWL 2 has three profiles or sublanguages [15] derived by trading off expressiveness for reasoning efficiency. These include OWL 2 EL, OWL 2 QL and OWL 2 RL. 2.3 OWL Tools and Applications To infer logical consequences from assertions made in an ontology, OWL reasoners are used [16]. They can be used for classification, debugging, subsumption, satisfiability, instance retrieval and conjunctive query answering. Some of the popular OWL reasoners are HermiT [17], Pellet [18], Fact++ [19] etc. They differ in terms of their implementation language, reasoning functions they provide and OWL Description Logic format they support. The OWL API [3], compliant with the W3C OWL 2 specifications, provides the functionality for loading, parsing, serializing, querying, inferencing and reasoning, and updating the ontologies. It also provides explanation of entailments made by the OWL reasoner and modules extraction from ontologies.

3 3 3 Navigation in Ontologies Major navigation tasks involved in understanding and utilizing an ontology include overview, focusing and zooming, and filtering [20]. Numerous navigation and visualization techniques using a variety of two-dimensional (2D) and three-dimensional (3D) methods have been developed for ontologies. Some of the visualization tools are Indented Lists, Node-link Graphs and Trees, Zooming, Space-filling, Focus, Context and Distortion. On the other hand, the non-visualization tools include OWL API [3], Locality-based Modularity, LOD Laundromat [21] etc. Various comparison surveys of these tools are found in the literature [22]. Table 1 summarizes the strengths and shortcomings of these tools. Clearly, these tools may be suitable for various kinds of applications, nature of the ontology and the tasks required to be accomplished. Table 1. Advantages and Disadvantages of Existing Navigation Tools Navigation Category Indented Lists Node-link Graphs and Trees Zooming Space-filling Focus, Context and Distortion OWL API Advantages overview of hierarchy simple, no clutter or overlap overview of hierarchy flexibility of view locating specific nodes color and size coding overview of instances global overview locating specific nodes quick and elaborate locating specific nodes Disadvantages only inheritance relationships multiple inheritance not clear excessive scrolling required labels not fully visible overlapping and cluttering no global context ineffective for structurerelated tasks no overview of hierarchical structure task-specific functions only 3.1 Key Concept Extraction The Key Concept Extraction (KCE) algorithm [23], incorporated in KC-Viz [24], provides a reduced form of ontology to make the visualization clearer and comprehensive. Each concept in the ontology is assigned an importance score using the statistical and topological measures of density, coverage and natural category, etc. The density refers to richness of a concept in terms of properties and relationships it has with other concepts. Coverage of the ontology in its hierarchy of relationships is to be maximized. Natural category evaluates the measures like name simplicity and how basic level the names of concepts are. The final score is evaluated as a weighted sum of the values of these parameters for each of the concept. The high scoring concepts are the ones that are more central and significant to the ontology domain. KCE API 4 provides the implementation of this algorithm. 4 last accessed 2017/06/07

4 4 3.2 Handling Large Ontologies Katifori et al. [22] consider that for large ontologies, the semantic zooming of the concepts is much more beneficial and desirable than the geometrical scaling in the visualization. Moreover, the notion of reducing the ontology size by clustering methods or hiding nodes is also recommended [25] which is where the Key Concepts Extraction algorithm [23] comes into play. This is because instead of dealing with the entire ontologies with all the classes, only a subset of its most significant concepts can be utilized for navigational tasks. These summarized ontologies have been shown to be significantly correlated to experts-produced versions in terms of key concepts extracted [23]. The prototype presented in this paper incorporates KCE algorithm to obtain a summarized version of large ontologies instead of all its details. The ontology engineers can then use this reduced version as an initial point for in-depth navigation of further concepts in the ontology. 4 Navigation in Large Ontologies Prototype 4.1 System Features The prototype development activity was carried out over a span of three sprints following the agile software development methodology. Each sprint was designed to add certain features which were then tested. The details of these sprints are given below: Sprint One. In the first sprint, the basic requirements of a tool for navigation in large ontologies were implemented. These include construction of a convenient graphical user interface for the user providing the functionality to upload an ontology (.owl files only). As a result, the system displays the ontology summary using OWL API [3] functions and overview in the form of a hierarchical tree constructed from most significant concepts obtained from KCE algorithm [23]. Additionally, zooming and focusing functionality through search for a concept from the loaded ontology using the Pellet reasoner [18] were added. The search was designed to return all the subclasses, super classes, disjoint classes, equivalent classes and individuals for the search seed. The modularization tools from OWL API [3] were also incorporated provide filtering mechanism. Sprint Two. Sprint two was majorly focused on building upon the existing functionalities developed in sprint one and adding advanced features as well. They included the functionality to load ontology from its URI, search for multiple signature seeds from a user-provided comma-separated list of concepts, OR and AND combinations of seeds in search results, modularization for multiple signature seeds, save the modularized components as a standalone ontology, and provide configurable top concepts for KCE hierarchy tree construction.

5 5 Sprint Three. This sprint was focused on making optimizations in the system to further improve its efficiency for large ontologies. KCE hierarchy tree construction was optimized by adding a restriction to run this if there are less than 10,000 concepts. For other cases, a two-step overview could be achieved by first obtaining a module from very large ontology and then getting its overview tree. A mechanism was also implemented to save the results of KCE algorithm [23] in a text file after it runs on an ontology. Whenever the same ontology was loaded into the system again, the already saved results were used to build the hierarchy tree, hence saving time and resources. This required serialization and de-serialization of the object that holds the taxonomy with importance scores which was achieved by incorporating a wrapper over the original functions from KCE API. 4.2 System Architecture The system had three basic structural layers, i.e., the prototype application, OWL API and KCE API. The application layer was the main functionality hub where the user interface (UI) and the underlying code was implemented. The interactions with the ontology were carried out by making a transaction with the OWL API layer to use the ontology-related functions. The KCE API layer handled the transfer of data between the KCE algorithm [23] and the KCE taxonomy object to populate the algorithm results which was then communicated to the code in application layer. An additional layer, the KCE wrapper, was added to achieve the serialization/de-serialization mechanism to save and retrieve the KCE taxonomy object with evaluated importance scores for all the concepts. Fig. 1. System Architecture for the Prototype

6 6 5 Prototype s Performance Evaluation The tool s performance was evaluated using large ontologies for carrying out navigation tasks such as zooming in/out, extracting and focusing on specific parts of the information. Table 3 gives the open source ontologies used in evaluation along with the number of classes, axioms and logical axioms they contain. Table 2. Ontologies Selected for Evaluation Ontology Classes Axioms Logical Axioms SNOMED-CT 5 326,654 1,477, ,665 SNOMED 6 319,369 1,448, ,380 NCI Thesaurus 7 125,523 1,891, ,208 GENE 8 48, , ,665 Full Galen 9 23,141 63,329 37,696 SUMO 10 4, , ,752 Galen 11 2,748 7,690 4,529 Pizza Ontology Table 3. Comparison of Loading Time (seconds) Prototype for Navigation in Large Ontologies Protégé Ontology Browser OWLViz (Protégé) OntoGraf (Protégé) KC-Viz (Ne- On Toolkit) SNOMED-CT 28 GC overhead limit exceeded SNOMED 28 GC overhead limit exceeded NCI Thesaurus 14 GC overhead limit exceeded GENE 19 GC overhead limit exceeded Full Galen GC overhead limit exceeded SUMO GC overhead limit exceeded Galen Provided by Dr.-Ing Renate Schmidt, University of Manchester on 2017/05/ last accessed 2017/04/ last accessed 2017/04/ last accessed 2017/04/ last accessed 2017/04/ last accessed 2017/04/ last accessed 2017/04/ last accessed 2017/03/01

7 7 To benchmark the performance of the prototype with the existing navigation tools, a comparative study was carried out. The existing systems used in this testing include Protégé and its plugins OWLViz version and OntoGraf version 1.0.1, and KC- Viz [24] which is a plugin for NeOn Toolkit. The timing measurements given in Table 4 are for loading the respective ontologies in all these tools, with ontologies given in the decreasing order of their size. This information is presented in a graphical form with bar chart shown in Figure 2. Fig. 2. Comparison of Loading Time (seconds) The results obtained were quite surprising as none of the existing tools was able to even load most of the large ontologies, let alone allow any navigation tasks. They all completely failed to work with any ontology with the order of a hundred thousand axioms in it. On the contrary, the prototype presented in this paper was able to not only load these ontologies but also perform all the navigation tasks. The reason behind this was that all these tools try to fetch all the details of the ontology at once which takes up all the resources choking the system. The prototype developed here, however, adopted an approach of extracting information gradually on user-demand rather than fetching everything in the beginning. Therefore, it can be easily inferred that this tool outperforms all the others and can support ontology engineering tasks in very large ontologies. 5.1 Case Study To examine the behavior of the prototype for navigation tasks, two case studies were conducted. They were also insightful for determining the quantitative measure of user actions required to perform a task and the qualitative measures of user experience and ease-of-use while using a real-world ontology.

8 8 Case Study I. The first part of this case study was to load and navigate in an ontology that is smaller in size and known to the user. The reason behind this was to evaluate the performance of the prototype and compare the usage for ontology engineering tasks with other tools. Since Pizza Ontology, with 99 classes and 940 axioms, was already being used for understanding and practice usage of the OWL API [3], so it was used here. This case study revealed certain interesting points from the comparison of this prototype and Protégé. Several features like modularization and module saving that were added into the prototype were not available in Protégé forcing the engineer to use other tools to perform those tasks. All of them, however, could be accomplished from the same tool developed here while requiring minimal number of user actions. Case Study II. As a proof of concept, NCI Thesaurus, with 125,523 concepts and 1,891,914 axioms was used for this case study. The plan was to perform the zooming and filtering tasks according to the steps followed in the first case study for both the prototype and Protégé. However, Protégé ontology browser failed to load this large ontology altogether and hence, the tasks performance could not be compared. This case study again exhibited that the existing ontology navigation tools are not able to process such large ontologies making it impossible to perform any navigation or visualization tasks. Whereas in the case of this prototype, although at first, the system does not display an overview of the ontology, modularization, filtering and zooming can still be performed. This gradual extraction of information from the ontology on user-request is what makes this prototype tool more suitable for navigation in large ontologies. 6 Conclusion and Future Work The aim of this paper was to introduce a system that enables the ontology engineers to perform navigational tasks like overview, filtering, focusing etc. in large ontologies. Several tools for ontology browsing, navigation and visualization were studied and used to understand their working and issues they face for large ontologies. The literature also suggested that for very large ontologies, instead of extracting all the information, a reduced form of ontologies could be more beneficial. Moreover, visualization simply does not work because of limited screen space and cluttering issues. Two important findings were incorporated in the prototype. Firstly, the OWL API [3] was used to access, manipulate and perform ontology operations programmatically. Secondly, the KCE API that employs Key Concept Extraction (KCE) algorithm [23] to extract the most significant concepts from an ontology based on certain importance factors such as coverage, density and natural category was utilized. The prototype was developed using agile framework by dividing the job over three sprints for implementing prototype features, adding advanced features and performing optimizations respectively. To benchmark this tool with others, the timing evaluations were made for same tasks for a few large ontologies. This revealed a significant achievement of this prototype that it allowed the navigation in very large ontologies

9 9 (more than 100,000 concepts) where all the other existing tools completely failed. The user-experience and convenience were analyzed through two case studies showing that this prototype was very simple and self-guiding for the user. From the analysis of evaluation results, it can be safely concluded that this system has successfully delivered the requirement of performing navigational tasks on large ontologies. A few recommendations for future work on this prototype are mentioned here. For a better user understanding, the results could be made to display class labels rather than IRIs. For extremely large ontologies, the garbage collector (GC) overhead limit must be handled accordingly. Currently, the system only accepts ontologies in.owl files. To increase its application range, it can be made to accept other data sources (CSV, Excel sheets, databases etc.) as user input. References 1. Gruber, T. R.: A Translation Approach to Portable Ontology Specifications. Knowledge Acquisition 5(2), (1993). 2. Borst, P., Akkermans, H., Top, J.: Engineering Ontologies. International Journal of Human-Computer Studies 46(2-3), (1997). 3. Horridge, M., Bechhofer, S.: The OWL API: A Java API for OWL Ontologies. Semantic Web 2(1), (2011). 4. Jiao, Z. L., Liu, Q., Li, Y.-F., Marriott, K., Wybrow, M.: Visualization of Large Ontologies with Landmarks. In: GRAPP/IVAPP, pp (2013). 5. Hitzler, P., Kr otzsch, M., Parsia, B., Patel-Schneider, P. F., Rudolph, S.: OWL 2 Web Ontology Language Primer. W3C Recommendation 27(1), 123 (2009). 6. Amann, B., Cnam, C., Martin, R. S., Fundulaki, I.: Integrating Ontologies and Thesauri to Build RDF Schemas. In ECDL-99: Research and Advanced Technologies for Digital Libraries, Lecture Notes in Computer Science, Vol. 99, pp , Springer (1999). 7. Lord, P.: Components of an Ontology. Ontogenesis (2010). 8. McGuinness, D. L., Van Harmelen, F.: OWL Web Ontology Language Overview. W3C Recommendation 10(10), (2004). 9. Patel-Schneider, P. F., Hayes, P., Horrocks, I.: OWLWeb Ontology Language Semantics and Abstract Syntax. W3C Recommendation, 10, (2004). 10. Motik, B., Parsia, B., Patel-Schneider, P. F.: OWL 2 Web Ontology Language XML Serialization. World Wide Web Consortium, (2009). 11. Motik, B., Patel-Schneider, P. F., Parsia, B., Bock, C., Fokoue, A., Haase, P., Hoekstra, R., Horrocks, I., Ruttenberg, A., Sattler, U.: OWL 2 Web Ontology Language: Structural Specification and Functional-style Syntax. W3C Recommendation 27(65), (2009). 12. Horridge, M., Drummond, N., Goodwin, J., Rector, A., Wang, H. H.: The Manchester OWL Syntax. In: 2006 OWL Experiences and Directions Workshop (OWL-ED), (2006). 13. Beckett, D., Berners-Lee, T., Prudhommeaux, E., Carothers, G.: RDF 1.1 Turtle - Terse RDF Triple Language. W3C Recommendation, (2014). 14. Kr otzsch, M.: OWL 2 Profiles: An Introduction to Lightweight Ontology Languages. In: Reasoning Web International Summer School, pp Springer, (2012). 15. Motik, B., Grau, B. C., Horrocks, I.,Wu, Z., Fokoue, A., Lutz, C.: OWL 2 Web Ontology Language Profiles. W3C Recommendation 27, 61 (2009). 16. Dentler, K., Cornet, R., Ten Teije, A., De Keizer, N.: Comparison of Reasoners for Large Ontologies in the OWL 2 EL Profile. Semantic Web 2(2), (2011).

10 Glimm, B., Horrocks, I., Motik, B., Stoilos, G., Wang, Z.: HermiT: An OWL 2 Reasoner. Journal of Automated Reasoning 53(3), (2014). 18. Sirin, E., Parsia, B., Grau, B. C., Kalyanpur, A., Katz, Y.: Pellet: A Practical OWL-DL Reasoner. Web Semantics: Science, Services and Agents on the World Wide Web 5(2), (2007). 19. Tsarkov, D., Horrocks, I.: FaCT++ Description Logic Reasoner: System Description. In: Third International Joint Conference on Automated Reasoning, pp Springer Berlin Heidelberg, Berlin, Heidelberg (2006). 20. Jiao, Z. L., Liu, Q., Li, Y.-F., Marriott, K., Wybrow, M.: Visualization of Large Ontologies with Landmarks. In: GRAPP/IVAPP, pp (2013). 21. Beek, W., Rietveld, L., Bazoobandi, H. R., Wielemaker, J., Schlobach, S.: LOD Laundromat: A Uniform Way of Publishing Other People s Dirty Data. In: 13th International Semantic Web Conference - Part I, ISWC 14, pp Springer-Verlag New York, Inc., New York, NY, USA (2014). 22. Katifori, A., Halatsis, C., Lepouras, G., Vassilakis, C., Giannopoulou, E.: Ontology Visualization Methods - A Survey. ACM Computing Survey (CSUR) 39(4), 10 (2007). 23. Peroni, S., Motta, E., daquin, M.: Identifying Key Concepts in an Ontology, through the Integration of Cognitive Principles with Statistical and Topological Measures. In: 3rd Asian Semantic Web Conference on The Semantic Web, pp Springer, Berlin, Heidelberg (2008). 24. Motta, E., Peroni, S., Li, N., d Aquin, M.: KC-Viz: A Novel Approach to Visualizing and Navigating Ontologies. (2010). 25. Van Ham, F., van Wijk, J. J.: BeamTrees: Compact Visualization of Large Hierarchies. In: IEEE Symposium on Information Visualization (InfoVis, 2002), 2(1), (2002).