Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

4) Ontologies

No description
by

Marco Brandizi

on 7 April 2014

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of 4) Ontologies

Giving meaning to RDF and Linked Open Data
Schemas in
the SW/LOD:
i.e, Ontologies

RDF-S
OWL
OWL Tricks
SKOS
Standard
Ontologies

Schemas in the SW World
Which category?
How does it relate
to sub/super categories?
Which type of property is it?
What kind of entities does it link?
Is it related to 'involved in'?
Sounds similar to... ontology
Image source: http://commons.wikimedia.org/wiki/File:Raphael_School_of_Athens.jpg
What can be said to exist?
Into what categories, if any, can we sort existing things?
What are the meanings of being?
What are the various modes of being of entities?
"An ontology is a description (like a formal specification of a program) of the concepts and relationships that can formally exist for an agent or a community of agents." [Tom Gruber, 1995]
RDF-S (i.e., Schema): Classes
@prefix dbpedia: <http://dbpedia.org/page/>.
@prefix ex: <http://www.example.com/>.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.

dbpedia:Sandro_Veronesi rdf:type ex:Oncologist. # or just 'a'

ex:Oncologist rdfs:subClassOf ex:Doctor;
rdfs:comment "The class of doctors who are specialized in oncology".

ex:Doctor rdfs:subClassOf ex:Person.
ex:Person a rdfs:Class.
ex:Oncologist rdfs:subClassOf ex:Person, rdfs:Class.
ex:Doctor rdfs:subClassOf rdfs:Class.
ex:Person rdfs:subClassOf rdfs:Class.

dbpedia:Sandro_Veronesi
a ex:Doctor, ex:Person.
It's still RDF, i.e., it's reflexive
(like XML-Schema)
Logically implies these further statements
Software products that 'understand' RDF-S can yield logical implications for you, from explicit triples
Other applications can take advantage of it
e.g.: 'Tell me all the doctors in Italy'
RDF-S: Properties
dbpedia:Sandro_Veronesi
ex:president-of dbpedia dbpedia:Istituto_Europeo_di_Oncologia.

ex:president-of rdfs:subPropertyOf ex:involved-in;
rdfs:label 'is president of'.

ex:involved-in a rdfs:Property;
rdfs:domain ex:Person;
rdfs:range ex:Organization.
dbpedia:Sandro_Veronesi a ex:Person.
dbpedia:Istituto_Europeo_di_Oncologia a ex:Organization
Logically implies
can be used by applications to display:

"Veronesi is president of IEO"

which keeps the SW behind the scenes

So, use is recommended.

Individuals (or instances), typically in a triple store (e.g., Virtuoso), typically tons of them, defined from converters or other apps
Schema/Ontology, typically loaded from a file, defined through editors (e.g., Protegé)
The RDF-S Vocabulary
rdfs:Literal: to define properties taking values and not resources/URIs
XMLDatatype available in 1.1 (and extendable)
rdf:HTML available in 1.1
More at:
http://www.w3.org/TR/2000/CR-rdf-schema-20000327,
http://www.w3.org/TR/rdf11-concepts
We'd like more semantics
Idea: let's leverage logics*,
like Description Logics, let's
standardise it
* and RDF-S
Source: http://www.slideshare.net/lysander07/openhpi36
Source: http://www.slideshare.net/lysander07/openhpi36
Source: http://www.slideshare.net/lysander07/openhpi36
Source: http://www.slideshare.net/lysander07/openhpi36
Source: http://www.slideshare.net/lysander07/openhpi36
Veronesi
Person
Oncologist
Doctor
==> Web Ontology Language (OWL)
The OWL Vocabulary (on top of RDF-S)
source: http://www.w3.org/TR/owl2-rdf-based-semantics/
ex:CarDriver rdf:type owl:Class;
rdf:label "Car Driver".

ex:Cyclist a owl:Class;
rdf:label "Cyclist".

# Intersection
ex:EcoDriver rdfs:subClassOf ex:CarDriver, ex:Cyclist.

# Union
ex:RoadUser rdfs:subClassOf [
owl:unionOf ( ex:CarDriver ex:Cyclist )
].

ex:marco a RoadUser.
ex:paul a EcoDriver.
Several syntax flavours available (e.g., functional, Manchester)
it's still RDF, though the TTL representation is not extremely practical
for serious work, visual editors are used (Protegé, http://www.w3.org/wiki/Ontology_editors)

specific owl:Class(es) are needed, to accomodate extensions
differently than rdfs:subClassOf, rdfs:subPropertyOf
Sharp distinction between:
1) classes and individuals (i.e., class instances/members)
2) object predicates, data-related predicates, annotation predicates, e.g.,
ex:Veronesi ex:president-of ex:IEO
, links two individuals
ex:IEO ex:founded-in 1994
, links an individual to a datatype instance
ex:IEO ex:part-of ex:Building
(Building is a class)
It works, but OWL makes ex:Building both an individual and a class
=> performance issues, probably not what you want
Other property types are available to:
describe an ontology itself (e.g., owl:import)
annotation properties
e.g., ex:editor-note, dc:creator
Property types
# Transitive
ex:part-of a owl:TransitiveProperty

# Symmetric
ex:knows a owl:SymmetricProperty

# Inverse
ex:supervises owl:inverseOf ex:is-supervised-by

# and more (functional, equivalent, asymmetric, reflexive...)

# Chaining (defined in OWL-2)
ex:has-uncle a owl:propertyChainAxiom ( ex:has-dad ex:has-brother)
ex:mike ex:has-dad ex:john.
ex:john ex:has-brother ex:bob.
==> ex:mike ex:has-uncle ex:bob.
Restrictions
Existential
ex:Oncologist owl:equivalentClass ex:Doctor, [ a owl:Restriction;
owl:onProperty ex:has-specialization;
owl:someValuesFrom ex:OncologySpeciality ].

Again, it's RDF, but editors or other syntaxes are usually preferable:
ex:Oncologist EquivalentTo ( ex:has-specialization some ex:OncologySpeciality )

Universals
ex:Cow SubClassOf ( ex:eats only ex:Vegetable )

Cardinality (min, max also supported)
ex:Person SubClassOf ( ex:has-parent exactly 2 )
What's the point?
Property types
ex:ieo ex:located-in ex:milano.
ex:milano ex:part-of ex:italy.
ex:italy ex:part-of ex:europe.

ex:john foaf:knows ex:anne.

Property Restrictions
dbp:Umberto_Veronesi
ex:has-specialization ex:MammalCarcinoma.
select ?institute where {
?institute ex:located-in ?loc.
?loc ex-part-of ?ex:europe.
}
select ?doc where {
?doc a ex:Oncologist.
}
select ?anneFriend where {
ex:anne foaf:knows ?anneFriend.
}
# Person subclass of ( ex:has-parent only Person)
ex:beth ex:has-parent ex:nicole.
does not
imply ex:Person, cause subClassOf means it's only necessary
=> certain declarations are mostly informative
# Disjoint Classes
ex:Man owl:disjointWith ex:Woman.
ex:SchoolEmployee owl:disjointUnionOf ( ex:Teacher ex:Student ex:Administrator ).

# Complements
ex:Object owl:complementOf ex:LivingBeing.

# Enumerations
ex:SmithFamily owl:equivalentClass owl:oneOf ( ex:john, ex:lucy ex:anne ).

# Different individuals
[ a owl:AllDifferent; owl:distinctMembers ex:john, ex:lucy, ex:anne ].
More on class constructs
Tricks with OWL
It's axiomatic, you declare axioms, rather than providing all the facts
ex:caroline
a ex:Cow;
ex:eats ex:steak101. # Suppose cows eat only veggy food.
ex:steak101 a ex:MeatFood.

=>
It is valid
, leads to steak101 a VegetableFood.
Axiomatic approach and Open World Assumption ongoing
==> You cannot use OWL to validate, in the same sense you use SQL constraints
But you can still do some useful validation:
steak101 a MeatFood.
MeatFood disjointWith VegetableFood.
=> Will show you several possible contradictions

Another example (about class consistency):
ex:FishAndChips SubClassOf (ex:MeatFood and ex:VegetableFood)
=> ex:FishAndChips EquivalentTo Nothing
Not formally wrong, no error triggered, but a condition you can check
Tricks with OWL
No Unique Name Assumption (OWA again)
ex:Person rdfs:subClassOf ( ex:has-father ( exactly 1 ) ).
ex:john ex:has-father mark, paul.
=> ex:mark owl:sameAs ex:paul. NOT a validation error.
==> It's hard to establish identity. Options:
You live with it (you can check URIs separately)
Use key property declarations in OWL-2 (e.g., HasKey ( Book has-isbn) )
inverse-functional properties were used in OWL-1 (probably slower)


Object and data properties need to be kept distinct, you cannot use object properties to point straight at classes (unless you’re looking for troubles)
biosample-123 derived-from HomoSapiens.
essentially wrong, you actually mean:
biosample-123 derived-from [ a HomoSapiens ].
=> make things cumbersome, you need to hide it to the end user
OWL-2 introduced the punning mechanism, but not such a great improvement in my opinion.
As if it wasn't enough...
The more expressivity/constructs/inference you want, the more performance issues
you need more memory, more CPU
Very expressive logics are also undecidable (as OWL Full)
Many triple stores offer inference that cross these predefined categories, e.g.,
Virtuoso, not much more that RDF-S
Jena, a bit less than OWL-DL
Image Source: http://tinyurl.com/n58vvxq
RDF-S
all concepts are owl individuals and instances of skos:Concept
Similar to the idea
of an ontology
Simple
Knowledge
Management
System (SKOS)
labeling vocabulary
less formal than OWL/DL,
still some inference possible
good for thesauries
it isn't as rigorous as owl:sameAs
helps integration (with disadvantages you might not be interested in)
even more informal
Source: Wikipedia
Standard schemas and Ontologies: examples
schema.org: a very lightweight and general 'ontology', for most common things
Google (and other search engines) supports it
RDFa: allows you to annotate your web pages with RDF statements
RDFa + schema.org + other ontologies(*): allows you to be more visibile on Google
Potentially lets Google know more than it can "understand" via text mining
(*) Examples:
Dublin Core (general document metadata
FOAF (people's relationships)
SIOC (Blogs, web sites, social networks)
Standard schemas and Ontologies: examples
GoodRelations: a raher rich ontology to describe commercial products, businesses and alike
BestBuy known to be using it
Google is probably detecting it

Standard schemas and Ontologies: examples
Most biomedical ontologies stored in bioportal.org
Most of them are 'hard' ontologies
extend an upper ontology (BFO) and are based on shared principles (Smith et al) and common practices
Use advanced OWL/logics features
Often are very large, heterogeneous, integrated


Standard schemas and Ontologies: examples
Please go to: http://www.slideshare.net/tommasodinoia/vocabolari
for the Tommaso's slides
Advanced OWL
Reasoning

Advanced OWL Reasoning
Please go to: http://tiny.cc/wejydx
for the Cristiano's slides
Full transcript