OWL Manipulation toward Building Semantic Applications and Agents

Pooyan Balouchian (1), Amin Almassian (1), Atilla Elci (1,2) (1) Department of Computer Engineering – Eastern Mediterranean University

(2) Internet Technology Research Center pooyan.balouchian@emu.edu.tr , amin.almassian@emu.edu.tr , atilla.elci@emu.edu.tr

Abstract

Traditional websites no longer meet the needs of today’s software agents because of their unstructured nature in terms of the semantics they convey. One of the primary objectives of semantic web is to enable software agents infer facts and knowledge out of different websites. The primary aim of this project is to develop an application to manipulate OWL files, browse ontologies and enable software agents infer information semantically. Needless to say such inference is not feasible in current conventional applications. We have considered the Conference Ontology, extracted from the Ontology Repository of the University of Manchester as our sample ontology. From architectural point of view, we used a three-layer architecture. Due to the similarity of current web applications with the architecture we used, we were able to have an actual comparison made between the two approaches.

1. Introduction

Many efforts have been made to improve the way information is stored and retrieved on the web. The problem with today’s web content is its semi-structured nature. Semantic web was introduced to cover this gap and bring meaning to the web content. Unfortunately there are not many applications working semantically on the web, even though lots of research work has been performed in this area.

Due to the fact that semantic web technology is relatively new, advancements in this field have been mostly restricted to Ontology Development and not semantic web application development. Ontology development is of utmost importance and considered as the first step toward building semantic applications. The aim of this study has been to develop a web application by making use of a Conference Ontology,

developed in OWL, in order to observe the results of building a semantic web application in practice.

The paper is organized as follows. In section 2, the Conference Ontology, chosen as the knowledge base, will be discussed. Section 3 deals with the details of the architecture of the application developed. Section 4 discusses the semantic versus conventional application development. This section also compares relational and semantic approach of data management, as well as accessibility and usability of data schemas on the web. Section 5 considers the way object oriented programming environments deal with semantic knowledge bases. The experiences gained during the development of the web application, are discussed in section 6. Finally we conclude the paper in section 7.

2. Conference Ontology

Science and technology can be transferred through scientific conferences, where new inventions and discoveries are introduced by researchers. Such conferences play an important role in exchange of science. Therefore Conference Ontology, extracted from the ontology repository of the University of Manchester was selected as the subject of this research [1]. Figure 1 below displays the class structure of this ontology; we inserted numerous individuals as well which are not shown.

This ontology has been developed, using OWL (Web Ontology Language), which is the latest recommendation of W3C, and is probably the most popular language for creating ontologies today [2]. There are 46 Classes, 18 Datatype properties as well as 47 Object properties within the Conference Ontology. As the name suggests, Conference Ontology has been primarily designed to express details in the context of a scientific conference. Therefore, the tendency in designing this ontology has been towards scientific conferences.

2009 33rd Annual IEEE International Computer Software and Applications Conference

0730-3157/09 $25.00 © 2009 IEEE

DOI 10.1109/COMPSAC.2009.115

56

Figure 1 – Conference Taxonomy

3. Specifications of the Application Developed

This application aims at providing a web-based facility, through which users without any understanding of semantic web can also work. Therefore the user interface has not merely targeted professional users. Figure 2 below, clearly depicts the implementation view of the application architecture:

Figure 2 – Implementation Layers

On the first layer, the Conference Ontology plays a two-fold role. Firstly, it is serving as a Data Schema and secondly as a Data Storage. It is a Data Schema, because of the Classes and their Relationships and it is a Data Storage, because of the individuals stored within the ontology. As mentioned above the ontology is developed using OWL. The 2nd layer, OwlDotNetApi [3], is a component, serving as a middleware between the Conference Ontology and Conference Business Process. In other words, this component is serving as a library function and, as the developers of the application, we invoke the functions embedded in this component to be able to manipulate the Conference Ontology. As shown in the 3rd layer, the Business Process communicates with the OwlDotNetApi in order to have access to the Data Schema as well as the Data Storage simultaneously. The function of the Business Process layer is to shape the business rules associated with the domain of the application and not the domain of the ontology. Finally, the presentation layer aims at presenting knowledge to human users.

Figure 3 shows a sample run of the developed application:

57

Figure 3 – Application User Interface

Following you will find part of the Conference Ontology, divided into 4 different parts: Classes, Object Properties, Datatype Properties and Individuals. This part of the ontology is describing a specific papersubmitted to SIN Conference [4, www.sinconf.org] along with some details of the paper.

<!-- *********CLASS DEFINITIONS*********** -->

<rdfs:Class rdf:ID="Abstract" /><rdfs:Class rdf:ID="Conference_volume" /><rdfs:Class rdf:ID="Person" /><owl:Class rdf:ID="Presentation" />

<owl:Class rdf:ID="Paper"><rdfs:subClassOf>

<owl:Class rdf:ID="Regular_contribution" /></rdfs:subClassOf></owl:Class>

<owl:Class rdf:ID="Poster" />

<!-- ********* OBJECT PROPERTIES *********** -->

<owl:ObjectProperty rdf:ID="contributes"><owl:inverseOf>

<owl:ObjectProperty rdf:ID="has_authors" /></owl:inverseOf></owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="is_submitted_at"><owl:inverseOf>

<owl:ObjectProperty rdf:ID="has_contributions" /></owl:inverseOf>

<rdfs:range rdf:resource="#Conference_volume" /><rdfs:domain rdf:resource="#Paper" />

</owl:ObjectProperty><owl:ObjectProperty rdf:about="#has_authors">

<owl:inverseOf rdf:resource="#contributes" /><rdfs:range rdf:resource="#Person" /><rdfs:domain rdf:resource="#Paper" />

</owl:ObjectProperty><owl:ObjectProperty rdf:about="#has_contributions">

<owl:inverseOf rdf:resource="#is_submitted_at" /></owl:ObjectProperty>

<owl:FunctionalProperty rdf:ID="has_an_abstract">

<owl:inverseOf><owl:InverseFunctionalProperty

rdf:ID="is_the_1th_part_of" /></owl:inverseOf>

<rdfs:range rdf:resource="#Abstract" /><rdf:type

rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty" />

<rdfs:domain><owl:Class><owl:unionOf rdf:parseType="Collection">

<owl:Class rdf:about="#Paper" /><owl:Class rdf:about="#Poster" />

<owl:Class rdf:about="#Presentation" /></owl:unionOf></owl:Class></rdfs:domain></owl:FunctionalProperty>

<!-- ********* DATATYPE PROPERTIES *********** -->

<owl:FunctionalProperty rdf:ID="has_a_date_of_issue"><rdf:type

rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty" />

<rdfs:rangerdf:resource="http://www.w3.org/2001/XMLSchema#date" />

<rdfs:domain rdf:resource="#Paper" /></owl:FunctionalProperty>

<owl:InverseFunctionalProperty rdf:about="#is_the_1th_part_of">

<owl:inverseOf rdf:resource="#has_an_abstract" /></owl:InverseFunctionalProperty>

<!-- ********* INDIVIDUALS *********** -->

<Person rdf:ID="AuthorMarjanehSafaei"><contributes rdf:resource=”#SemanticMappingPaper” />

</Person>

<Person rdf:ID="Marjaneh_Safaei" /><Conference_volume rdf:ID="SINConf_Volume_2" />

<Paper rdf:ID="SemanticMappingPaper"><has_a_date_of_issue

rdf:datatype="http://www.w3.org/2001/XMLSchema#date">2009-03-10</has_a_date_of_issue>

<is_submitted_at><Conference_volume rdf:ID="SINConfVolume2"><has_contributions

rdf:resource="#SemanticMappingPaper" /></Conference_volume></is_submitted_at>

<has_authors rdf:resource="#AuthorMarjanehSafaei" /><has_an_abstract><Abstract rdf:ID="SemanticMappingPaper_Abstract"><is_the_1th_part_of

rdf:resource="#SemanticMappingPaper" /></Abstract></has_an_abstract></Paper>

Let us now see how the OWL file is processed and climbs up the architecture’s layers step by step, starting from the Data Access Layer (DAL) up to the Presentation Layer (PL). As shown in Figure 2 the Conference Ontology, acting as our data schema is fetched by the OwlDotNetApi which is in fact an

58

interface between the DAL and the Business Logic Layer (BLL). The OwlDotNetApi class diagram is depicted in Figure 4 below.

Figure 4 – OwlDotNetApi Class Diagram

It is worth mentioning that specific changes have been made to this API to best suit the application. As shown in the figure, each element within the ontology is represented using the OwlNode class. Each node is considered either as an OWL Resource or an OWL Literal. It is actually the OWL Resource which helps us provide data with semantics. An OWL Literal is only a string of characters without any semantics involved. The OWL Property can be an Ontology Property, Datatype Property, Object Property or Annotation Property. In the Conference Ontology, mostly object and datatype properties are involved and hence the focus of our application is on processing these owl properties. Having passed the OwlDotNetApi layer, our BLL is responsible to receive the ontology nodes and prepare the grounds for the ontology to be used in the PL, where the user is involved. The BLL, regardless of the nature of data schema in its lower layer, is able to process the given data toward fulfilling the requirements of the business.

In our PL, we are using a top-down approach. First the user is able to enter the ontology URL, either a local copy or one on the web. The application then displays the ontology taxonomy, as shown in Figure 5, where the user is able to browse the ontology for further retrieval of information.

Figure 5 – Ontology Class View

By choosing a class, all individuals of that class’s type will be displayed to the user. Finally by choosing an individual, all the details of the chosen individual are shown to the user as depicted in Figure 6 below. A triple in OWL has the form of <subject> <predicate> <object>, where <subject> is an individual, having the relationship <predicate> with another individual <object>. For instance, as shown in Figure 6, the “SemanticMappingPaper” has been selected. You can see 4 properties extracted related to the selected individual, “has_an_abstract”, “has_authors”, “is_submitted_at” and “has_a_date_of_issue”. It is important to note that in all these properties, “SemanticMappingPaper” plays the role of <subject> and the properties as <object>. Obviously each of these <object>s can play the role of <subject> if selected for further retrieval.

Having mentioned the specifications of the developed application, let’s now consider the differences between the semantic implementation of web application versus the conventional implementation. Afterwards, we will discuss all the

59

actual findings in result of development of this application.

Figure 6 – Sample Individual

4. Semantic vs. Conventional Implementation

Semantic implementation of web applications is nowadays becoming more common. A web application with a semantic-based backend is far different from a conventional implementation. The main difference between the two approaches is the level of expressivity of knowledge and the way data is stored. In this section we point out the major differences between the semantic and conventional implementation of web applications, encountered during our research.

4.1. Relational vs. Semantic

Before the advent of semantic web and even today, nearly all web applications have been and are using Relational Database Management Systems (RDBMSs). Nevertheless sooner or later the applications will have a semantic-based backend. Let’s see why there is a distinction between these two approaches. The data stored in a RDBMS is only structured but not semantically meaningful. Data are stored in the form of records and the only relationship among the data associated with one record is that they appear in the same record. Let’s take into consideration a table called STUDENT in a RDBMS with two attributes

NAME and SURNAME. The information of all students is stored in the said table. As an example, JOHN is a student, with surname HOPKINS. The only relationship which JOHN has with HOPKINS according to this schema is that they appear on the same row in the table STUDENT. In order to create such a relationship, we have to create a new table and given a large-scale project, you will soon find it impossible to create such a relationship for all attributes in all tables. Moreover, the RDBMS does not understand the meaning of NAME and SURNAME.

Semantic web indeed has solutions to cover the weaknesses pointed out above. Its major purpose is to make the information on the web, machine-understandable; that is, enabling software agents to infer knowledge out of websites. Unlike the relational approach, it will be a simple task to use semantic technology to create relations between different entities in the ontology and restrict such relations accordingly.

Nevertheless, there seems to be a common weakness in both approaches. When it comes to knowledge representation to human and not the machine, lack of data structure in presentation layer is apparent. However semantic web has provided solution for communication among machines through software agents. Let’s consider the idea of having a semantic presentation layer open for further research.

4.2. Accessibility & Reusability

One of the other noticeable differences between the two approaches is accessibility to an ontology versus a database schema. Having access to a relational database schema is equal to having access to the data stored within that schema, but this is not the case in semantic methodology. Having access to a namespace, does not mean that we have access to the ontologies using that namespace. In other words, database schema is not sharable, whereas ontology schema is. Semantic web makes it possible for any developer to access ontologies already designed by another developer using Uniform Resource Identifiers (URIs), which forms the first layer of the Semantic Web Protocol Stack. This makes information on the web not only more accessible but also reusable. Reusability of ontologies on the web saves a lot of time for developers, creating an ontology, similar to those already developed by others.

60

5. Semantic Implementation using Object Oriented Programming

Semantic web represents knowledge in a more understandable and machine-readable format. It is in fact a kind of knowledge representation technique to represent the information stored in the knowledge base to end users by taking advantage of a programming language. Since the advent of object oriented programming languages, they have become very common and widely used in the development of desktop or web-based applications. This fact has persuaded researchers to work on compatibility of semantic web technology and OOP languages. Information is processed in the context of an ontology in a different way compared to OOP environments. Today researchers are struggling in this area to somehow unify such processing in both environments. When the information is pulled out of the ontology and enters the programming language environment, it becomes very hard to process them as they were being processed within the ontology itself. The reason may be the amount of expressivity that ontologies provide compared to OOP environments.

6. Research Experiences

During development of any project, the researcher gains valuable experiences worth remembering. Following you will find a portion of such experiences obtained during the life cycle of this project. It is necessary to mention that this is only a personal view and does not form a general formula. � We spent some time to get familiar with the

chosen ontology. Had we spent this amount of time to develop the ontology from scratch, we wouldn’t have been able to achieve a quality and ideal ontology within the specified time limit.

� Finding an ontology, already applied in some applications does not mean that you have found a perfect and error-free ontology. Ontologies are always subject to enhancements and therefore it is recommended not to trust ontologies the way you trust other principles.

� The Identity Strategy chosen for identifying the individuals in an ontology, plays an important role in software development. The reason behind this fact is that we use global namespaces when developing ontologies. What if two developers identify the same thing in two different ways or identify two different things in the same way?

� The current OWL APIs might not be well matured. You, as the developer of an application,

may have to modify the component to best suit your purpose. The reason we do not benefit from complete OWL APIs may be the young life of the field.

7. Conclusion

In this paper, we addressed the existing gaps in development of semantic web applications. From the advent of semantic web, more effort has been made on ontological aspects and less on semantic application development.

As we all know, theory is far away from practice. Concepts which are theoretically proven may not be practically proven. To take one step further toward building semantic applications and agents, we made use of a Conference Ontology in OWL, an Object Oriented Programming Language and OwlDotNetApi [3], as the bridge between the Ontology and OOP environment. This application is capable of processing an ontology in its Data Access Layer and providing the Presentation Layer with a user-friendly representation of the ontology. Comparisons have been made between the conventional web applications and agents and the semantic ones. By the time developers tend to build their applications semantically, actually the grounds for inter-operability of machines in a semantic fashion will be prepared.

8. References

[1] http://owl.cs.manchester.ac.uk/repository/browser[2] L. Yu, Introduction to the Semantic web and Semantic Web Services, Chapman & Hall/CRC Taylor & Francis group, United States of America, 2007. [3] http://users.skynet.be/bpellens/OwlDotNetApi/owldotnetapi.html[4] Security of Information and Networks (Proceedings of the First International Conference on Security of Information and Networks (SIN 2007)) by Elçi, A., Ors, B., & Preneel, B. (eds.) Trafford Publishing, Canada. 2008. ISBN: 978-1-4251-4109-7.[5] M. Hepp, P. D. Leenheer, Ontology Management; Semantic Web, Semantic Web Services, and Business Applications, Springer Science + Business Media LLC, United States of America, 2008. [6] A. F. Salam, Jason R. Stevens, Semantic Web Technologies & E-Business, Toward the Integrated Virtual Organization and Business Process Automation, Idea Group Publishing, United States of America and United Kingdom, 2007.[7] J. Davis, R. Studer, P. Warren, Semantic Web Technologies, Trends and Research in Ontology-based Systems, John Wiley & Sons Ltd., United Kingdom, 2006.

61