Introduction to Ontologies

woodruffpassionateInternet και Εφαρμογές Web

21 Οκτ 2013 (πριν από 3 χρόνια και 1 μήνα)

148 εμφανίσεις

Introduction to Ontologies

focussing on OWL

Nick Drummond

Overview


Getting to Know OWL


How Can I Recognise OWL?


OWL Constructs Overview


More About Classes


More About Properties


Reasoners & Inference


Is OWL Dangerous?


Common Mistakes


The Open World Problem



Creating & Using OWL


Where Can I find Examples?

Getting to Know OWL


OWL is the
W
eb
O
ntology
L
anguage



It’s part of the





Semantic Web framework



It’s a


standard

OWL Has Explicit Semantics

Can therefore be used to capture knowledge
in a machine understandable way

Class (BlueThing) does not mean anything

Class (BlueThing complete


owl:Thing


restriction (hasColour someValuesFrom (Blue))
)

OWL Helps Us…

Describe something, rather than just name it.

Lite

partially restricted to aid learning curve

lite

DL = Description Logic

Description Logics are a fragment of
First Order Logic (FOL) that can be
reasoned with

DL

Full

unrestricted use of OWL
constructs, but cannot reason

Full

OWL comes in 3 Flavours


OWL is often thought of as an
extension to RDF which is not
strictly true


OWL is a syntax independent
language that has several
common representations


Abstract Syntax


N3


RDF/XML


Many tools try to completely
abstract away from the syntax

How Can I Recognise OWL?


One of the clearer human
-
readable syntaxes


Class(SpicyPizza complete


annotation(rdfs:label "PizzaTemperada"@pt)


annotation(rdfs:comment "Any pizza that has a spicy topping






is a SpicyPizza"@en)


Pizza


restriction(hasTopping someValuesFrom(SpicyTopping))

)

OWL Syntax:
abstract syntax


Recommended for human
-
readable fragments


default:SpicyPizza


a owl:Class ;


rdfs:comment "Any pizza that has a spicy topping is a





SpicyPizza"@en ;


rdfs:label "PizzaTemperada"@pt ;


owl:equivalentClass


[ a owl:Class ;


owl:intersectionOf (default:Pizza [ a owl:Restriction ;


owl:onProperty default:hasTopping ;


owl:someValuesFrom default:SpicyTopping


])


] .


OWL Syntax: N3


Recommended for serialisation



<owl:Class rdf:ID="SpicyPizza">


<rdfs:label xml:lang="pt">PizzaTemperada</rdfs:label>


<rdfs:comment xml:lang="en">Any pizza that has a spicy topping is a
SpicyPizza</rdfs:comment>


<owl:equivalentClass>


<owl:Class>


<owl:intersectionOf rdf:parseType="Collection">


<owl:Class rdf:about="#Pizza"/>


<owl:Restriction>


<owl:onProperty>


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


</owl:onProperty>


<owl:someValuesFrom rdf:resource="#SpicyTopping"/>


</owl:Restriction>


</owl:intersectionOf>


</owl:Class>


</owl:equivalentClass>


</owl:Class>

OWL Syntax: RDF/XML

Tools “Hiding the Syntax”


In the tools, you are more
likely to find OWL looking
more like a tree of classes


And their descriptions

Person

Country

Class (concept)

Animal

Individual (instance)

Belgium

Paraguay

China

Latvia

Elvis

Hai

Holger

Kylie

S.Claus

Rudolph

Flipper

arrow = relationship

label = Property

OWL Constructs Overview

Eg Mammal, Tree, Person, Building, Fluid, Company


Classes are
sets

of Individuals


aka “Type”, “Concept”, “Category”, “Kind”


Membership of a Class is dependent on its
logical
description
, not its name


Classes do not have to be named


they can be logical
expressions


eg
things that have colour Blue

OWL Constructs: Classes

Eg hasPart, isInhabitedBy, isNextTo, occursBefore


Properties are used to relate Individuals


We often say that Individuals are related
along

a given property


Relationships in OWL are
binary
:



Subject


predicate


Object


Individual a


hasProperty


Individual b


nick_drummond


givesTalk


owl_overview_talk_Dec_2005

OWL Constructs: Properties

Eg me, you, this talk, this room


Individuals are the
objects

in our domain of interest


aka “Instance”, “Object”


Individuals may be (and are likely to be) a member of
multiple Classes

OWL Constructs: Individuals


Describing a Class Hierarchy


Types of Class


Describing the Classes


Relationships in OWL

More About Classes

Describing a Class Hierarchy

2 important things to say about classes:


Where can we put them?


Where can’t we put them?

Animal

Shark

Hot Air Balloon?


Subsumption is the primary axis (relationship) in OWL


Superclass/subclass relationship, “isa”


All

members of a subclass must be members of its superclasses



Animal subsumes Shark



Animal is a superclass of Shark



Shark is a subclass of Animal



All

Sharks are also Animals

owl:Thing

superclass of all Classes

Shark

Animal

Subsumption in OWL

Where can we put this class?

Where can’t we put this class?

Regardless of where they exist in the hierarchy,
OWL assumes that classes can overlap

Animal

Hot Air Balloon

= individual

By default, an individual could be both an
Animal

and a
Hot Air
Balloon

at the same time

Disjointness in OWL

Where can’t we put this class?

Stating that 2 classes are disjoint means

Hot Air Balloon

= individual

Something cannot be both an
Animal

and a
Hot Air Balloon

at the
same time

Animal

Disjointness in OWL

Hot Air Balloon

can never be a subclass of
Animal

(and vice
-
versa)

This can help us find errors


Types of Class

owl:Thing (everything)

owl:Nothing

(nothing)

Animal (primitive named class)

hasDangerLevel some Dangerous

(anonymous class
-

restriction)

DangerousAnimal (defined named class)

Primitive vs Defined

Blue Things

Sharks

“Smart Class”
Acts like a query

Describe the necessary
features of the members

Eg live underwater

Like primitive, but also:

define necessary

conditions that
are also sufficient to recognise a
member

Eg have colour Blue

“Natural Kinds”

“All

things that have colour blue
are members of this class”

“All sharks live underwater, but
not everything that lives
underwater is a shark”

Anonymous Classes


Made up of logical expressions


Unions and Intersections (Or, And)


Complements (Not)


Enumerations (specified membership)


Restrictions (related to Property use)



The members of an anonymous class are the
set of Individuals that satisfy its logical definition

Relationships in OWL


In OWL
-
DL, relationships can only be formed
between Individuals or between an Individual
and a data value.

(In OWL
-
Full, Classes can be related, but this cannot be reasoned with)


Relationships are formed
along Properties


We can restrict how these Properties are used:


Globally


by stating things about the Property itself


Or locally


by
restricting

their use for a given Class

Restrictions


Restrictions are a type of anonymous
class


They describe the relationships that must
hold for members (Individuals) of this class

An example

Existential restriction on primitive class
Shark
:

necessarily hasMouthPart some
Teeth

Shark

Teeth

“Every member of the
Shark

class must have at least one
mouthpart from the class
Teeth


An example

Existential restriction on primitive class
Shark
:

necessarily hasMouthPart some
Teeth

Shark

Teeth

“There can be no member of
Shark
, that does not have at least one
hasMouthPart relationship with an member of class
Teeth



Restriction Types



Existential,
someValuesFrom

“Some”, “At least one”



Universal,
allValuesFrom

“Only”



hasValue

“equals x”



Cardinality

“Exactly n”



Max Cardinality

“At most n”



Min Cardinality

“At least n”


Different Types:


Object Property


relates Individuals to Individuals


Datatype Property


relates Individuals to data (int, string, float etc)


Annotation Property


for attaching metadata to classes, individuals or properties

More About Properties

Property Characteristics


Domain and range can be set


A property hierarchy can be created


Inverse properties can be set


Properties can be:


Transitive


Functional


Inverse Functional


Symmetric

Reasoner:

A clever (probably magic) black box designed by clever people

Best to let them worry about how they work

?

?

?

!

!

!

Reasoners & Inference

Reasoners: Inference


Reasoners are used to infer information that is
not explicitly contained within the ontology


You may also hear them being referred to as
Classifiers



Standard reasoner services are:


Consistency Checking


Subsumption Checking (Automatic Subsumption)


Equivalence Checking


Instantiation Checking

Consistency Checking

Shark

(primitive class)


Animal and


eats some (
Person

and
Seal
)

Person

Seal

Inconsistent

=
cannot contain any individuals

Disjoint

(Person, Seal)

Person
and

Seal = empty

Cannot have
some empty

Automatic Classification

Trivial example

DangerousAnimal

(defined class)


Animal and


hasMouthPart some
Teeth

Shark

(primitive class)


Animal and


hasMouthPart some
Fangs

Teeth

Fangs

When to use a Reasoner


We often use one during development as
an ontology
compiler
. A well designed
ontology can be compiled to check its
meaning is that intended


Or at
publish time



so many inferences
are already made for the user apps


Or at
runtime

in applications as a
querying mechanism (esp. useful for
smaller ontologies)

Reasoners and the tools


Many of the editing tools and APIs support the use of
reasoners implementing the
DIG interface


This means that the reasoner you choose is
independent of the application using it
, so you can
choose the implementation you want depending on your
needs (eg some may be more optimised for
speed/memory, others may have more features)


These reasoners typically set up a service running
locally or on a remote server


Protégé
-
OWL, for example can connect to reasoners
over an http:// connection


Yes, in the wrong hands!!


3 major issues


Because of the explicit semantics its important
that OWL be used as intended


Learning OWL is non
-
trivial and some
common mistakes are made by most
beginners


OWL operates under the Open World
Assumption

Is OWL Dangerous?

Use OWL Correctly


As we’ve seen, OWL is more than just a
syntax


Please do not decide to interpret it in your
own way


Doing this makes reuse impossible

Common Modelling Mistakes


Some of the common mistakes made when
modelling have been enumerated


They include:


Misuse of property domain and range


Misunderstanding of intersections and other
constructs


Not understanding the
Open World Assumption


Misuse/lack of of disjoints


See
OWL Pizzas: Common errors & common patterns

http://www.co
-
ode.org/resources/papers/

Open World Assumption


In a closed world (like DBs), the information we have is
everything



On the Semantic Web, we want people to be able to
extend our models. In this open world, we assume there
can always more information added later



Where a database, for example, returns a negative if it
cannot find some data, the reasoner makes no
assumption about the
completeness

of the information
it is given



The reasoner cannot determine something does not hold
unless it is
explicitly stated in the model

Open World Assumption





hasMouthPart some



Do sharks have a trunk?


Can sharks fly hot air balloons?

Closure





hasMouthPart some




hasMouthPart only



Sharks definitely cannot have trunks

(as long as Trunks are disjoint from Teeth)


But someone could still extend our description to
say that Sharks can fly Hot Air Balloons


Issues


Editors


Programming APIs


Storage


Reasoners

Creating & Using OWL

Issues


Suitability for purpose


Open vs Closed World problems


When to use a reasoner


How to expose/hide the ontology


Interfaces/ontology services


Ontology Development Methodologies


Small team, tight knit


Open “folksonomies”


Editing the RDF/XML by hand is probably not
recommended (as we have seen)



Ontologies range in size, but because of their explicit
nature they require verbose definitions



Thankfully we have tools to help us reduce the syntactic
complexity


However, the tools are still in the process of trying to
reduce the semantic complexity



Building ontologies in OWL is still hard

Editing OWL

OWL Editors

http://www.xml.com/pub/a/2004/07/14/onto.html


Is a knowledge modelling environment


Is free, open source software


Is developed by Stanford Medical
Informatics


Has a large user community (approx 30k)


http://protege.stanford.edu


core is based on object oriented modelling


has an open architecture that allows other
modelling languages to be built on top


supports development of
plugins

to allow
backend / interface extensions


supports OWL through the
Protégé
-
OWL

plugin

Programming with OWL


Protégé OWL API


Wonderweb OWL API


Jena



pOWL API


API features


Parsing / Serialisation


Model Manipulation


Reasoning


Querying


Modularisation

Storage of OWL


Files (RDF/XML)


Databases (triplestores)


3Store


Sesame


Jena


InstanceStore (Individuals)

Reasoners


FaCT++


Pellet


RACER


The w3c OWL pages are a good place to
start


The w3c Semantic Web Best Practices
and Deployment Working Group


Tutorials and courses run by Manchester
and other establishments generate a large
number of examples (eg CS646)

Where Can I Find Examples?

Example Ontologies


OBO


Open BioMedical Ontologies


The Gene Ontology


Bio tutorial and Pizza tutorial examples on
the CO
-
ODE site


Libraries are commonly published on OWL
editor websites


Search using Google or Swoogle


Example Applications


PizzaFinder (dummy query application)



COHSE


dynamic hyperlinking using ontologies



Protein Phosphatase Modelling


ask Robert Stevens



OWL Validator



GONG (Gene Ontology Next Generation)



AKT


http://www.aktors.org/



The Semantic Web Challenge


http://challenge.semanticweb.org/


For tutorial materials, examples and links
to some of the tools go to the CO
-
ODE
site






http://www.co
-
ode.org/

(in)famous pizza tutorial

Where Do I Go Next?