Ontology alignment representation

Ontology Alignment Representation

Fran¸ois Scharﬀe
c

Semantic Technology Institute (STI)
University of Innsbruck, Austria

April 14, 2008

Fran¸ois Scharﬀe (STI Innsbruck)
c Ontology Alignment Representation April 14, 2008 1 / 34

Outline

Introduction
Ontology mediation
Example

Actual limitations of the approach

Three levels of knowledge abstraction
SPARQL for instance transformation
The Alignment Format and Ontology

Correspondence Patterns
Patterns
Pattern template
Pattern library
Database mapping to ontologies patterns

Conclusion


Introduction Ontology mediation

Situation

Many ontologies overlap



Situation

Need to exchange data between applications/services/agents



Situation

Need to exchange data between applications/services/agents
Ontology mediation is the set of techniques making this data
exchange possible



Two phases ontology mediation

Two phases can be distiguished in ontology mediation:
Constructing an alignment (matching, graphical tool).



Two phases ontology mediation

Two phases can be distiguished in ontology mediation:
Constructing an alignment (matching, graphical tool).
Processing the alignment for a mediation task (data translation,
ontology merging, query rewriting)



Ontology Alignment

Deﬁnition (Alignment, correspondence)
Given two ontologies o and o , an alignment between o and o is a set of
correspondences (i.e., 4-uples): e, e , r , n with
e ∈ o and e ∈ o being the two matched entities,
r being a relationship holding between e and e , and
n expressing the level of conﬁdence [0..1] in this correspondence.


Introduction Example

Example 1: wines from Bordeaux

A BordeauxWine is a wine produced in the Bordeaux region.

Class
wine:BordeauxWine vin:Vin http://.../Château-Marguaux
http://.../Château-Margaux
Correspondence
vin:terroir vin:terroir

Attribute value geo:Location geo:Bordelais
restriction
Attribute value
restriction pattern

Figure: Bordeaux wines



Problem

while many matching algorithms, many graphical tools are out there,
there is not something such as a common format that would allow to
exchange alignments they output.



Problem

while the correspondence such as the one in the precedent example
occurs frequently, no algorithm is able to automatically detect it.



Problem

We cope with these issues in the following way



Problem

We provide an alignment representation formalism allowing
exchange of alignments through their lifecycle



Problem

We provide an alignment representation formalism allowing
exchange of alignments through their lifecycle
We formalize aspects of recurring correspondences and extract
patterns that will provide support for constructing alignments.



three levels of abstraction for ontology alignment representation

We implement this framework on the three levels.



at the ground level: mediation rules or grounded correspondences
(expressed in OWL, COWL, SWRL, WSML variants, SPARQL++,
etc.).




etc.).
at the intermediate level: alignment (expressed in a particular rule or
object model of a tool/algorithm)




etc.).
at the top level of abstraction: correspondence patterns (new
concept)



etc.).
concept)
at the ground level: a SPARQL extension for data transformation



etc.).
concept)
at the intermediate level: the Alignment format and the Alignment
Ontology



etc.).
concept)
at the intermediate level: the Alignment format and the Alignment
Ontology
at the top level: a library of recurring correspondence patterns


Three levels of knowledge abstraction SPARQL for instance transformation

SPARQL++ for instance transformation

We propose to use SPARQL as a convenient data translation language for
RDF.
it allows to query data




RDF.
its CONSTRUCT statement allows to translate graphs fragments




RDF.
It’s a W3C recommendation and is already supported by numerous
tools




RDF.
It’s a W3C recommendation and is already supported by numerous
tools
However, features of SPARQL are not mature enough to express
complex mappings: we thus propose an extension:SPARQL++



Simple example (Translate from VCard to FOAF)

vCard FOAF

VCard:FN foaf:name

CONSTRUCT { ?X foaf:name ?Y }
WHERE { ?X VCard:FN ?Y }



Simple example (Translate from VCard to FOAF)

vCard FOAF

VCard:FN foaf:name

CONSTRUCT { ?X foaf:name ?Y }
WHERE { ?X VCard:FN ?Y }

Easy! Supported by standard SPARQL



Built-in functions and value generation

vCard FOAF

foaf:name

VCard:Given

VCard:Family

CONSTRUCT { ?X foaf:name fn:concat(?N,quot; quot;,?F }
WHERE { ?X VCard:Given ?N. ?X VCard:Family ?F }



Built-in functions and value generation

vCard FOAF

foaf:name

VCard:Given

VCard:Family

CONSTRUCT { ?X foaf:name fn:concat(?N,quot; quot;,?F }
WHERE { ?X VCard:Given ?N. ?X VCard:Family ?F }

This is not possible in standard SPARQL



Example: Aggregates

Translate from DOAP to RDF Open Source Software Vocabulary



Example: Aggregates

Translate from DOAP to RDF Open Source Software Vocabulary

CONSTRUCT { ?P os:latestRelease
MAX(?V : ?P doap:release ?R. ?R doap:revision ?V) }
WHERE { ?P rdf:type doap:Project . }



Example: regular path expressions (pSPARQL)

o1 o2

+ o1:parentOf
o2:ancestorOf




o1 o2

+ o1:parentOf
o2:ancestorOf

CONSTRUCTs with regular path expressions can cater for that, this is
possible in pSPARQL:




o1 o2

+ o1:parentOf
o2:ancestorOf


CONSTRUCT { ?X o2:ancestor ?Y }
WHERE { ?X o1:parentOf+ ?Y . }




o1 o2

+ o1:parentOf
o2:ancestorOf


CONSTRUCT { ?X o2:ancestor ?Y }
WHERE { ?X o1:parentOf+ ?Y . }

pSPARQL oﬀers even more: full regular expressions over paths conditions
over paths, etc.



SPARQL++ was published at OTM 2007. The paper contains details
of the extension, semantics, and implementation details.
pSPARQL integration in our alignment framework was published at
OnAv 2008.


Three levels of knowledge abstraction The Alignment Format and Ontology

Motivation and requirements

considering the alignment as a ﬁrst-class citizen




being independent from the ontology formalism




being independent from the ontology formalism
being able to represent correspondences between ontological entities



The Alignment Ontology

Models the ontology alignment domain




Classes, Attributes, Relations and Instances for the entities




One to one, many to many, using set operators on the entities




Heterogeneous correspondences




Conditions can restrict entities scope




Transformations of attributes values




Paths




Paths
Model theoretic based semantics



The Alignment Format

Example serialization of Cell instances (RDF/XML):
FOAF persons based in Innsbruck have a particular VCard phone extension:
<Cell>
<entity1>
<Class rdf:about=quot;&foaf;Personquot;>
<attributeValueCondition>
<Restriction>
<onProperty rdf:resource=quot;&foaf;based_nearquot;/>
<comparator rdf:datatype=quot;&xsd;stringquot;>xsd:equals</comparator>
<value rdf:datatype=quot;&xsd;stringquot;>Fortaleza</value>
</Restriction>
</attributeValueCondition>
</Class>
</entity1>



The alignment format as an exchange format (2)

<entity2>
<Class rdf:about=quot;&v;VCardquot;>
<attributeValueCondition>
<Restriction>
<onProperty rdf:resource=quot;&v;workTelquot;/>
<comparator rdf:datatype=quot;&xsd;stringquot;>xsd:startsWith</comparat
<value rdf:datatype=quot;&xsd;stringquot;>+0043512</value>
</Restriction>
</attributeValueCondition>
</Class>
</entity2>
<measure RDF:datatype=’&BSD;float’>1.0</measure>
<relation>equivalence</relation>
</Cell>



Alignments semantics

Based on [Zimmermann 2006] and largely compliant with description
logics.

Syntax level o o




logics.

Syntax level o o
I I
Local semantics level D D




logics.

Syntax level o o
I I

Global semantics level D




logics.

A
Syntax level o o
I I I

Global semantics level D



Entity semantics

The semantics of expressions are interpreted within D through:

∀x ∈ QL (o), o I (x) ∈ D



Expression semantics

The expression semantics is typically the semantics of a description logic:

I (c) = o I (c)
I (C C ) = I (C ) ∪ I (C )
I (C C ) = I (C ) ∩ I (C )
I (¬C ) = D − I (C )
I (∃K ) = {x ∈ D|∃y ∈ D; x, y ∈ I (K )}



Alignment processing

The combined alignment API (INRIA) and Mapping API allow to parse
alignments and ground them for execution.


Correspondence Patterns Patterns

Patterns in the literature

Capture recurring knowledge




Facilitate the design task by using known structures




Facilitate the design task by using known structures
Facilitate semi-automatic design


Correspondence Patterns Pattern template

Pattern template elements

Name: give a meaningful name for the pattern, corresponds to a
fragment of the URI associated with the pattern.




Alias: alternative name




Problem: A statement describing the intent, goals of the patterns,
which entities are involved in the correspondence.




Context: refers to the context of usage for the pattern (speciﬁc
domain, speciﬁc application)




Solution: describe the result of using the pattern.




Example: example alignment representing this pattern




Related Patterns: relationships between this pattern and others




Related Patterns: relationships between this pattern and others
Known uses: URIs of existing alignments using this patterns



Example pattern: Aggregation pattern

http://www.ubuntu.org/ os:LatestVersion quot;8.04quot;
os:Software os:LatestVersion String

Class Attribute Attribute Value
Correspondence Correspondence aggregation (MAX)
Aggregation Pattern

doap:Project doap:realease doap:Version doap:revision values
Warty Warthog doap:revision quot;4.10quot;
http://www.ubuntu.org/ doap:realease Hoary Hedgehog doap:revision quot;5.04quot;
... ... ...
Hardy Heron doap:revision quot;8.04quot;

Figure: Aggregation Pattern



Example pattern: RCA-A pattern

http://.../francois vc:VCard
foaf:Person http://.../francois
Attribute Relation
vc:name vc:name Correspondence

Class Attribute
_:bn01
foaf:name foaf:name
vc:N Correspondence

quot;Scharffequot; vc:family-name Value
quot;Françoisquot; Transformation value
vc:given-name quot;François Vincent
Concatenation Alfred Scharffequot;
quot;Vincent Alfredquot; vc:additional-name
RCA-A concat
Pattern

Figure: Relation Class Attribute to Attribute Pattern


Correspondence Patterns Pattern library

Pattern library

Implemented as an ontology extending the Alignment Ontology with
speciﬁc patterns properties.



Pattern library

Sets of placeholders entities to be replaced during patterns
instantiation.



Pattern library

Sets of placeholders entities to be replaced during patterns
instantiation.
Around 40 patterns available.



Pattern library(2)

Figure: Overview of the patterns library


Correspondence Patterns Database mapping to ontologies patterns

Database mapping to ontologies

Direct Mapping A table in the database directly corresponds to a concept
in the ontology. There is a one-to-one correspondence
between records in the table and instances of the concept.
This pattern is modeled on the basis of the Class equivalence
correspondence pattern.
Join/Union A set of database tables corresponds to a concept in the
ontology when they are joined. There is a one-to-one
correspondence between join records of the joined tables and
instances of an ontology concept. This pattern is modeled
on the Class Union pattern.



Database mapping to ontologies (2)

Projection A subset of the columns of a database table are needed to
map a concept in the ontology. This pattern is modeled on
the basis of the Class By Attribute Type pattern, where the
scope of the class (the table) is restricted to the speciﬁc
attributes (columns).
Selection A subset of the rows of a database table map a concept in
the ontology. This pattern is modeled on the basis of the
Class By Attribute Value, rrestrictingthe scope of the class
(the table) to only those instances (the table rows) having a
given value for the speciﬁed aattributes(columns).



Database mapping to ontologies (3)

Value transformation A column in an table corresponds to an attribute in
the ontology after transformation of its value using a
transformation function. This pattern is modeled on the
basis of the Attribute Transformation pattern.
Combinations Combinations of the aforementioned patterns are also
possible.


Conclusion

Conclusion

This thesis
Introduces a new three layered framework reﬂecting the ontology
mediation landscape:


Conclusion

Conclusion

This thesis
1. Mediation rules with the introduction of a SPARQL extension for
instance transformation.


Conclusion

Conclusion

This thesis
2. Ontology Alignment with the introduction of a alignment
representation formalism: language and ontology.


Conclusion

Conclusion

This thesis
2. Ontology Alignment with the introduction of a alignment
representation formalism: language and ontology.
3. Correspondence patterns introduced, formalized, reference patterns
library.


Conclusion

Ongoing and Future works

Write the thesis !


Conclusion


Write the thesis !
Groundings to SPARQL++


Conclusion


Write the thesis !
Extend the pattern library with domain and application speciﬁc
patterns.


Conclusion


Write the thesis !
Extend the pattern library with domain and application speciﬁc
patterns.
Study how patterns can assist matching algorithms to discover
complex matches.


Conclusion

Thank you for your attention !

Questions ?


Ontology alignment representation

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (20)

More from François Scharffe

More from François Scharffe (10)

Recently uploaded

Recently uploaded (20)

Ontology alignment representation