Types of Ontologies

Ontologies can be categorized into four different types (van Heijst et al., 1997), namely: application ontologies, domain ontologies, generic ontologies and representation ontologies.

Application ontologies contain the knowledge needed to model a particular application. Domain ontologies express concepts that are specific for a particular domain. Generic ontologies define concepts that are generic across different disciplines. Finally, representation ontologies provide a representational framework with a neutral view of the world.

There is also another classification of ontologies based on their generality (i.e. scope) and expressiveness (i.e. level of details) (Bruijn and Fensel, 2005). In the level of generality there are three different types of ontologies: top-level ontologies (e.g. CYC51, WordNet52) which are shared by many people in different domains, domain ontologies (e.g. UNSPSC53, The United Nations Standard Products and Services Code for classifying products and services) which are shared between stakeholders in a particular domain and finally application ontologies (e.g. an ontology for a course) which are used for a particular application.

The other orthogonal classification of ontologies is based on their expressiveness. Ontologies can be distinguished by their different levels of expressiveness such as: thesaurus (e.g. WordNet), controlled vocabulary (e.g. Dublin Core54), informal/formal taxonomy (e.g. Yahoo directory55/UNSPSC), frames (e.g. RDFS), value restrictions (e.g. OWL data-type), limited logic constraints (e.g. OWL DL56) and general logic constraints (e.g. CyCL57, OWL DL).

Finally, Bruijn and Fensel (2005) also mentioned that the level of expressiveness can be seen as two distinct categories: light-weight ontologies, which include the concepts and the relations between them and heavy-weight ontologies, which include axioms and constraints.

This thesis is going to focus on the use of application ontologies with a light-weight level of expressiveness.

51

http://www.opencyc.org/ [last accessed 11/2/2007]

52

http://wordnet.princeton.edu/ [last accessed 11/2/2007]

53

http://www. unspsc.org [last accessed 11/2/2007]

54

http://dublincore.org/ [last accessed 11/2/2007]

55

http://dir.yahoo.com/ [last accessed 11/2/2007]

56

http://www.w3.org/TR/owl-guide/ [last accessed 11/2/2007]

57

5.3

Ontology Languages

Prior to the initiative of the Semantic Web by Tim Berners Lee, many systems existed that used different languages to represent ontologies like SCL58, CyCL and LOOM59 (Bruijn and Fensel, 2005). Although they offer a powerful expression and reasoning mechanism, they still lack intimate support of RDF (the key language in the Semantic Web).

To express the semantics of a resource on the Web so that humans, as well as machines, can understand it, a set of formal languages are used. These languages can be stacked on top of each other to form what Berners-Lee (2000) called “The Semantic Web Language Layer Cake”.

Figure 5.1: The Semantic Web Language Layer Cake [Berners-Lee, 2000]60.

Figure 5.1 depicts the layers of the Semantic Web starting with: the Unicode and URI layer which forms the base for the upcoming layers. The second layer is the XML and XML Schema, which forms the syntactical basis for the Semantic Web languages. The third layer is the RDF and RDF Schema which represents the expressive language for the Semantic Web. The next layer is OWL, which represents the ontology language for the Semantic Web. An overview of each of the three languages used in the Semantic Web is presented in the following sub-sections, with

58

Simple Common Logic (SCL) http://www.ihmc.us/users/phayes/SCL-december.html [last accessed 11/2/2007]

59

http://www.isi.edu/isd/LOOM/ [last accessed 11/2/2007]

60

information derived from (Antoniou and van Harmelen, 2004), (W3C, 2001), (W3C, 2002) and (W3C, 2004).

5.3.1 XML/DTD/XML Schema

Although XML is not an ontology language; it is a core technology in the ‘Layer Cake’ and all the subsequent layers are built on top of it.

XML (eXtensible Markup Language) is an application of SGML (ISO 8879). It is a structured language and was developed due to the shortcomings of HTML.

XML is used to exchange data between web applications. To accomplish the exchange, applications need to agree on common vocabulary to support communication. From these vocabularies are MathML61 (for mathematics) and NewsML62 (for news).

An XML document consists of the following parts (Figure 5.2): Prolog, elements and attributes.

Figure 5.2: XML Snippet.

A prolog is a line that appears before the root element in an XML document. It contains XML declaration and reference to other documents (e.g. <?xml version=”1.0”?>). Elements represent the ‘things’ the XML document talks about (e.g. Authors). Finally, an attribute is a value inside the opening tag of an element (e.g. ISBN).

61

http://www.w3.org/Math/ [last accessed 11/2/2007]

62

http://www.newsml.org/pages/index.php [last accessed 11/2/2007] <?xml version="1.0" encoding="UTF-8"?> <Book>

<Authors>

Grigoris Antoniou and Frank van Harmelen. </Authors>

<title ISBN=”1234567”> A Semantic Web Primer </title>

An XML document is a well-formed document, which means it is restricted to a set of syntactic rules. XML structure can be defined using two methods:

• Document Type Definition (DTD) “old and hard”: the document can be within the XML file (internal) or on a separate file (external).

• XML Schema “new and easy”: its syntax is based on XML documents and it provides a richer language to define the structure of an XML document. The important feature in an XML schema is its ability to be reused and refined.

5.3.2 RDF/RDFS

RDF (Resource Description Framework) is a data model that consists of object- attribute-value triple called a statement. RDF triples can be expressed in different ways: by using XML syntax (Figure 5.3).

Figure 5.3: RDF serialization using XML.

Or using N3/Notation363 (Figure 5.4).

Figure 5.4: RDF in N3.

Or using binary predicate form, e.g. Property(object,value), Figure 5.5.

Figure 5.5: RDF as a binary predicate.

Or using a directed labelled graph (Figure 5.6).

Figure 5.6: RDF as a graph.

63

http://www.w3.org/DesignIssues/Notation3 [last accessed 11/2/2007]

http://www.example.com/Adam Name _Adam

<rdf:Description rdf:ID=" http://www.example.com/Adam"> <Name>Adam</Name>

</rdf:Description>

<http://www.example.com/Adam> <Name> "Adam" .

RDF is a domain independent language, where no claim about a specific domain is made. This implies the need to define someone’s own terminology using RDF Schema (RDFS). Also, RDF does not contain vocabulary to author metadata, thus an RDF Schema is needed to define a predefined vocabulary to be used with metadata generation.

RDFS is intended to model a domain in a hierarchical fashion which poses the problem of representing some ontological knowledge, thus RDFS is very limited. One example of this problem is the representation of the ‘disjointness of classes’, sometimes we wish to say that classes are disjoint, however, RDFS is not capable of representing this relation, it can only show the subclass relationship. Due to this limitation a more expressive language is needed (hence OWL).

5.3.3 OWL

Research groups both in the United States with their DAML ontology language and Europe with their OIL ontology language, identified the need for more powerful ontology language. Their joint efforts produced what is called as DAML+OIL ontology, which then was taken as a starting point for the W3C ontology working group in developing OWL (Web Ontology Language.) This language is aimed to be the standard ontology language for the Semantic Web.

OWL comes in three different flavours namely: OWL Lite, OWL DL and OWL Full. Each flavour differs in its level of expressiveness and reasoning.

• OWL Lite: is a limited version of OWL that provides a classification hierarchy and simple constraints. Examples of OWL Lite include thesauri and taxonomies.

• OWL Description Logic (DL): includes all OWL language constructs, and provides the maximum expressiveness while maintaining a finite computation time.

• OWL Full: includes all OWL language constructs, and provides the maximum expressiveness with no computational guarantees.

5.4

Building Ontologies

Ontologies can be generated either manually or semi-automatically (Gómez-Pérez and Manzano-Macho, 2004). Manual ontology building is a tedious, time-consuming and error-prone task. Semi-automatic building of ontologies is more appropriate for speeding up the process of ontology generation.

The process of semi-automatic generation of ontologies is usually referred as an ontology learning process, which can be defined as

“the application of a set of methods and techniques used for building an ontology from scratch by enriching, or adapting, an existing ontology in a semi-automatic fashion using distributed and heterogeneous knowledge and information sources, allowing a reduction in the time and effort needed in the ontology development process” (Gómez-Pérez and Manzano-Macho, 2004, p.187).

The process of ontology learning from text includes a number of methods that came from complementary disciplines (e.g. Natural Language Processing ‘NLP’ and machine learning) and is applied to different types of unstructured, semi-structured, and fully structured data. These methods can be summarized as follows (Gómez- Pérez and Manzano-Macho, 2004):

• Approaches based on linguistic techniques: These include NLP techniques such as pattern-based extraction, semantic relativeness, etc. An example of a system using this technique is SOAT (WU and HSU, 2002).

• Approaches based on statistical techniques: These methods rely on calculating several statistical measures (e.g. Term Frequency Inverse Document Frequency ‘TFIDF’) to help the ontologist detect new concepts and the relationships between them. As an example of a system based on this technique is WOLFIE (WOrd Learning From Interpreted Examples) (Thompson and Mooney, 1999).

• Approaches based on machine learning algorithms: These algorithms include all methods from the machine learning domain to assist the ontologist in detecting new concepts and their relations, and to help in placing them in the correct position in the taxonomy. As an example of a system that uses this technique is OntoLearn (Navigli et al., 2003).

Despite the wide area of ontology semi-automatic generation, this thesis used the manual technique to build its domain ontologies. This was due to two reasons: (1) the non-existence of pre-constructed ontologies in the thesis domain of interest and (2) to speed up the process of building the domain ontologies without the need to evaluate the validity of the resultant ontologies.

5.4.1 Existing Ontologies on the Web

Pre-constructed ontologies can be found either in ontology libraries, specialized search engines or portals. Many ontology libraries do exist on the web, for instance DARPA64 (DAML Ontology Library) contains around 280 ontologies written in the DAML ontology language. Ontologies in this library range from medical research to business. In addition, Stanford University holds another library of ontologies created using Protégé editor; this library is called Protégé Ontology Library65. Schemeweb66 is another source for pre-created ontologies. Also, OntoSelect67 is an ontology repository that harvests ontologies from the web. The user can browse ontologies according to size (number of classes, properties), representation format (DAML, RDFS, OWL), connectedness (score over the number of included and referring ontologies) and human languages used for the class/property labels. The library also supports ontology search. When searching using OntoSelect the returned results are ranked based on ontologies relevance.

Specialized search engines such as Swoogle68 can also help find ontologies on the web. Swoogle is capable of searching around 10,000 ontologies. Similarly, ONTOSEARCH269 is “a search and query engine for ontologies and ontological data on the Semantic Web. It allows ad-hoc queries across hundreds of OWL files using the SPARQL query language”.

64

http://www.daml.org/ontologies/ [last accessed 11/2/2007]

65

http://protege.cim3.net/cgi-bin/wiki.pl?ProtegeOntologiesLibrary [last accessed 11/2/2007]

66

http://www.schemaweb.info/schema/BrowseSchema.aspx [last accessed 11/2/2007]

67

http://olp.dfki.de/OntoSelect/index.php?mode=select [11/2/2007]

68

http://swoogle.umbc.edu/ [last accessed 11/2/2007]

69

Finally, ONTHOLOGY70 ("anthology of ontologies") is a portal for ontologies contributed by users. It uses the proposed Ontology Metadata Vocabulary (OMV) that is used to provide metadata descriptors to identify ontologies. OMV is like DC for documents. The portal contains 127 ontologies which someone can browse or search.