this material was developed with financial help of the wusa fund of austria

1/65This material was developed with financial help of the WUSA fund of Austria.

by Miloš Micić, mailto: [email protected]/65

Content

• RDF (Resource Description Framework)• OWL (Ontology Web Language)• OWL-S (OWL for Services)

• Semantic Search

• Markup Languages

Semantic WebSemantic Web

• XML (eXtended Markup Language)


Markup LanguagesMarkup Languages


The text contained within the documents were “marked up” using textual commands, explaining how to print the document.

text based software applications requirement

development of GML (Generalized Markup Language)

Integrated text editing

Separated formatting from the document’s text

Formatting and information retrieval

History of Markup LanguagesHistory of Markup Languages


development of SGML (Standard GML)

Text description language (structure and content)


development of XML (eXtended Markup Language)

Data description language (structure)

International standard in 1986

Base for other markup languages (HTML, XML…)

Enables data exchange on a global basis



1970 1990 2000 2010

SGML

HTML

XML

RDF

OWL


Parts of SGML DocumentParts of SGML Document Declaration

specifies which characters and delimiters may appear

DTD (Document Type Definition)

syntax of markup constructsdocument elementselement hierarchy possible sequence of tags

required number of element occurrences

Specificationdescribes the semantic to be ascribed to the markup

Document Instancescontain data and markup

contain a reference to the DTD to be used for interpretation


Pieces of Electronic DocumentPieces of Electronic Document

content

markup


Data Exchange

Semantics+reasoning

Relational Data

???

???

???

Markup Language PyramidMarkup Language Pyramid


The Relationship between The Relationship between SGML, HTML and XMLSGML, HTML and XML

complete document language

can define other markup languages

subset of SGML

also can define other markup languages

work with Web data

XML

SGML

display data

HTML

specific DTD of SGML

GML

SGML

XML HTML


Developing Semantic WebDeveloping Semantic Web XML enables data exchange but says nothing about meaning

Goal is to provide reasoning rules

Development roadmap, stepping stone:

knowledge representation

Inference

ontology

search


OntologyOntologyPrograms have to know that two terms have the same meaning. Solution is collection of information called ontology.

Ontology = document that defines the relations between terms.

Ontology=<taxonomy, inference rules>Taxonomy=<{classes},{relations}>

Example: “If a city code is associated with a state code, and an address uses that city code, than that address has the associated state code”.

A program could deduce, that an ETF address, being in Belgrade, must be in Serbia which is in the SCG and therefore should be formatted to SCG standards.


Family of XMLFamily of XMLMarkup LanguagesMarkup Languages


XML IntroductionXML Introduction designed to describe data

does not DO anything

Someone must write a piece of software to send, receive or display it.

<note> <to>Toma</to> <from>Suzana</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body>

</note>

cross-platform, software and hardware independent


XML IntroductionXML Introduction

XML tags

XML can separate data from HTML

case-sensitivenot predefined

properly nested hierarchy (without overlapping)

Mayor portions of the XML document (six ingredients)

1. XML Declaration (required)2. Document Type Definition (or XML Schema)

3. Elements (required)4. Attributes5. Entity6. Notations


Namespaces and URIsNamespaces and URIs namespaces provide a method to avoid element name conflicts

xmlns:namespace-prefix="namespaceURI"

URI (Uniform Resource Identifier) is a string of characters which identifies Internet Resource.

<h:table xmlns:h="http://www.w3.org/TR/html4/"> <h:tr> <h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr> </h:table>

using a default namespace<table xmlns="http://www.w3.org/TR/html4/"> <tr> <td>Apples</td> <td>Bananas</td> </tr> </table>

URI ensure that concepts are not just words in a document, but are tied to a unique definition that everyone can find on the Web.

17/65

1 XML Declaration1 XML Declaration

document prolog

<?xml version=“1.0” encoding =“ISO-8859-1”?><note>

<to>Toma</to> <from>Suzana</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body>

</note>

announcement to XML processor that the document is marked up in XML

18/65

2 Document Type Definition2 Document Type Definition(DTD)(DTD)

used for validating XML document

structural description of the XML document

Referring to a DTD is a request that the parser compare the document instance to a document model.

defines a legal building blocks of XML document

or (for internal DTD)<!DOCTYPE root_element [element_declaration]>

<?xml version=“1.0” encoding =“ISO-8859-1”?><!DOCTYPE note SYSTEM "note.dtd"> ... (internal definition)

optional but useful

19/65

2 Internal DTD, Example<?xml version="1.0"?> <!DOCTYPE note [ <!ELEMENT note (to,from,heading,body)> <!ELEMENT to (#PCDATA)> <!ELEMENT from (#PCDATA)> <!ELEMENT heading (#PCDATA)> <!ELEMENT body (#PCDATA)> ]> <note> <to>Toma</to> <from>Suzana</from> <heading>Reminder</heading> <body>Don't forget me this weekend</body> </note>


2 External DTD, Example<?xml version="1.0"?> <!DOCTYPE note SYSTEM "note.dtd"> <note> <to>Toma</to> <from>Suzana</from> <heading>Reminder</heading> <body>Don't forget me this weekend</body> </note>

<!–- “note.dtd” -->

<!ELEMENT note (to,from,heading,body)> <!ELEMENT to (#PCDATA)> <!ELEMENT from (#PCDATA)> <!ELEMENT heading (#PCDATA)> <!ELEMENT body (#PCDATA)>


2 XML Schema Definition (XSD)<!–- “note.xsd” --><?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3schools.com" xmlns=http://www.w3schools.com> <xs:element name="note"> <xs:complexType>

<xs:sequence> <xs:element name="to" type="xs:string"/> <xs:element name="from" type="xs:string"/> <xs:element name="heading" type="xs:string"/> <xs:element name="body" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element>

</xs:schema>

Complex element(have attributes orother elements)

Simple elements(contain only text)

elements defined in“note.xsd”came from w3schools

default namespace

decimal, integer,boolean, date,time


<?xml version="1.0"?>

<note xmlns="http://www.w3schools.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.w3schools.com note.xsd"> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body>

</note>

2 XML Schema Definition (XSD)

XML document has a reference to an XML schema


2 XML Schema Restrictions2 XML Schema Restrictions<xs:element name="password"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-zA-Z0-9]{8}"/> </xs:restriction> </xs:simpleType></xs:element><xs:element name="age"> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="0"/> <xs:maxInclusive value="100"/> </xs:restriction> </xs:simpleType></xs:element>

restrictions on a set of values restrictions on a series of values restrictions on length


3 XML Elements3 XML Elements building blocks of a document

nested hierarchy (parent – children relation)

only one root element

names must not start with “xml”, “XML” …

4 XML Attributes4 XML Attributes can be used to give an element a unique ID<note> <date> <day>12</day> <month>11</month> <year>2002</year> </date> <to>Toma</to> <from>Suzana</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note>

<note date="12/11/2002" to="Toma" from=“Suzana" heading="Reminder" body="Don't forget me this weekend!"> </note>

<note day="12" month="11" year="2002" to="Toma" from=“Suzana" heading="Reminder" body="Don't forget me this weekend!"> </note>


XML Family TreeXML Family TreeXML

Validation Languages

DTDXML

Schema

XML Location

Languages

DOM SAX XPATH XPOINTER& XLINK

XML Display

Languages

XSL

XSLT XSL-FO

XML Web

ServicesLanguages

SOAP WSDL UDDI


Resource Description Resource Description Framework (RDF)Framework (RDF)


XML -> RDF provide extra machine understandable layer

Resource Value

Subject Object

The book War and Peace

Property

Predicate

has the title

<?xml version=“1.0”?><rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” xmlns:dc=“http://purl.org/dc/elements/1.1/”> <rdf:Description rdf:about=“http://www.amazon.com/books”> <dc:title>War and Peace</dc:title> <rdf:Description>

</rdf:RDF>Subject

PredicateObject


"there is a Person identified by http://www.w3.org/People/EM/contact#me, whose name is Eric Miller, whose email address is [email protected], and whose title is

Dr."


4. Each RDF triple can be joined to other RDF triples, but still retains its own unique meaning, regardless of complexity.

1. Each RDF triple is made up of S, P, O.

2. Each RDF triple is complete and unique fact.

3. Subject is uri reference or blank node (represent a resource that isn’t currently identified). Predicate is uriref. Object is uri reference, blank node or literal.

Four important facts Four important facts about RDF tripletsabout RDF triplets


Container VocabularyContainer Vocabulary

<rdf:Bag>

<rdf:Alt>

<rdf:Seq>

used to describe a list of values that is intended to be unordered.

used to describe a list of values that is intended to be ordered (For example, in alphabetical order)

used to describe a list of alternative values (the user can select only one of the values).


<rdf:Bag> example<rdf:Bag> example

<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:cd="http://www.recshop.fake/cd#">

<rdf:Description rdf:about="http://www.recshop.fake/cd/Beatles"> <cd:artist> <rdf:Bag>

<rdf:li>John</rdf:li> <rdf:li>Paul</rdf:li> <rdf:li>George</rdf:li>

<rdf:li>Ringo</rdf:li> </rdf:Bag> </cd:artist> </rdf:Description>

</rdf:RDF>


"Course 6.001 has the students Amy, Mohamed, Johann, Maria, and Phuong" <rdf:Bag> example


<rdf:Alt> example<rdf:Alt> example

<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:cd="http://www.recshop.fake/cd#">

<rdf:Description rdf:about="http://www.recshop.fake/cd/Beatles"> <cd:format> <rdf:Alt> <rdf:li>CD</rdf:li> <rdf:li>Record</rdf:li> <rdf:li>Tape</rdf:li> </rdf:Alt> </cd:format> </rdf:Description>

</rdf:RDF>


Serialization (RDF in Serialization (RDF in XML)XML)

RDF/XML is used for transporting, interchange, collection and merging of data from multiple models

RDF/XML parsers does not use DTD or XML Schema to ensure that RDF/XML is valid

There is no way to stop many individuals from independently assigning URIs to represent

There could be many resources that represent the same tree ! ! ! ! ! !


RDF SchemaRDF Schema

can express classes and their relations (subClassOf)

Three most important RDF concepts:

rdfs:Resource

rdfs:Class

rdf:Property

defines properties and associate them with classes

focused on defining taxonomies (class hierarchy)


RDF Schema Class RDF Schema Class ExampleExample

<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="http://example.org/schemas/vehicles"> ... <rdfs:Class rdf:ID="MiniVan"> <rdfs:subClassOf rdf:resource="#Van"/> <rdfs:subClassOf rdf:resource="#PassengerVehicle"/> </rdfs:Class> </rdf:RDF>


RDF Schema Property RDF Schema Property ExampleExample

<rdf:Property rdf:ID="registeredTo"> <rdfs:domain rdf:resource="#MotorVehicle"/> <rdfs:range rdf:resource="#Person"/> </rdf:Property>

<rdf:Property rdf:ID="rearSeatLegRoom"> <rdfs:domain rdf:resource="#PassengerVehicle"/> <rdfs:range rdf:resource="&xsd;integer"/> </rdf:Property>

The registeredTo property applies to any MotorVehicle and its value is a Person


RDF Schema Instance RDF Schema Instance ExampleExample

<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/schemas/vehicles#" xml:base="http://example.org/things">

<ex:PassengerVehicle rdf:ID="johnSmithsCar"> <ex:registeredTo rdf:resource="http://www.example.org/staffid/85740“ /> <ex:rearSeatLegRoom rdf:datatype="&xsd;integer">127</ex:rearSeatLegRoom> </ex:PassengerVehicle>

</rdf:RDF>

Instance is described in a separate document from the schema.

#Person type


Web Ontology LanguageWeb Ontology Language (OWL)(OWL)


"Tell me what wines I should buy to serve with each course of the following menu. And, by the way, I don't like Sauternes."

OWL is not a message format. It is a knowledge representation.

provides three sublanguages

we must go beyond keywords and specify the meaning


OWL SublanguagesOWL Sublanguages OWL Lite

classification hierarchy

simple constraint features

OWL DL (Description Logic)maximum expressiveness and decidability of reasoning system

restrictions such as type separation(a class can not also be an individual or property, a property can not also be an individual or class)

OWL Full

syntactic freedom of RDF

(class can be treated simultaneously as a collection of individuals and as an individual in its own right)


<rdf:RDF xmlns:owl ="http://www.w3.org/2002/07/owl#" xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xsd =http://www.w3.org/2001/XMLSchema#xmlns:vin ="http://www.w3.org/TR/2004/REC-owl-guide-

20040210/wine#“xmlns:food="http://www.w3.org/TR/2004/REC-owl-guide-

20040210/food#">

<owl:Ontology rdf:about=""> <rdfs:comment>An example OWL ontology</rdfs:comment> <owl:priorVersion rdf:resource= "http://www.w3.org/TR/2003/PR-owl-guide-20031215/wine"/> <owl:imports rdf:resource= "http://www.w3.org/TR/2004/REC-owl-guide-20040210/food"/> <rdfs:label>Wine Ontology</rdfs:label> ...

Ontology HeadersOntology Headers

Importing another ontology brings the entire set of assertions provided by that ontology into the current ontology


ClassesClassesEach user-defined class is implicitly a subclass of owl:Thing.

<owl:Class rdf:ID="Winery"/> <owl:Class rdf:ID="Region"/> <owl:Class rdf:ID="ConsumableThing"/>

Within this document, the Region class can now be referred to using #Region, e.g. rdf:resource="#Region"

<owl:Class rdf:ID="Wine"> <rdfs:subClassOf rdf:resource="food:PotableLiquid"/> <rdfs:label xml:lang="en">wine</rdfs:label> <rdfs:label xml:lang="fr">vin</rdfs:label> ... </owl:Class>

<owl:Class rdf:ID="Pasta"> <rdfs:subClassOf rdf:resource="#EdibleThing" /> ... </owl:Class>


IndividualsIndividuals

<Region rdf:ID="CentralCoastRegion" />

Identical in the meaning to the example below:

<owl:Thing rdf:ID="CentralCoastRegion" /> <owl:Thing rdf:about="#CentralCoastRegion"> <rdf:type rdf:resource="#Region"/> </owl:Thing>

rdf:type is an RDF property that ties an individual to a class of which it is a member


Properties

<owl:ObjectProperty rdf:ID="locatedIn"> <rdfs:domain rdf:resource="http://www.w3.org/2002/07/owl#Thing" /> <rdfs:range rdf:resource="#Region" /> </owl:ObjectProperty>

Two types of properties:• DATATYPE PROPERTIES, relations between instances of classes and RDF literals and XML Schema datatypes

• OBJECT PROPERTIES, relations between instances of two classes

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

<owl:DatatypeProperty rdf:ID="yearValue"> <rdfs:domain rdf:resource="#VintageYear" /> <rdfs:range rdf:resource="&xsd;positiveInteger"/> </owl:DatatypeProperty>


Properties of Individuals

<VintageYear rdf:ID="Year1998"> <yearValue rdf:datatype="&xsd;positiveInteger">

1998 </yearValue> </VintageYear>

<Region rdf:ID="SantaCruzMountainsRegion"> <locatedIn rdf:resource="#CaliforniaRegion" /> </Region>

locatedIn is object property defined for Region instances

yearValue is datatype property defined for VintageYear instances


Property Characteristics

<owl:ObjectProperty rdf:ID="locatedIn"> <rdf:type rdf:resource="owl:TransitiveProperty" /> <rdfs:domain rdf:resource="owl:Thing" /> <rdfs:range rdf:resource="#Region" /> </owl:ObjectProperty>

<Region rdf:ID="SantaCruzMountainsRegion"> <locatedIn rdf:resource="#CaliforniaRegion" /> </Region>

<Region rdf:ID="CaliforniaRegion"> <locatedIn rdf:resource="#USRegion" /> </Region>

1. Transitive property

P(x,y) and P(y,z) implies P(x,z)

locatedIn is transitive property



<owl:ObjectProperty rdf:ID="adjacentRegion"> <rdf:type rdf:resource="&owl;SymmetricProperty" /> <rdfs:domain rdf:resource="#Region" /> <rdfs:range rdf:resource="#Region" /> </owl:ObjectProperty>

<Region rdf:ID=“SumadijaRegion"> <locatedIn rdf:resource="#SerbiaRegion" /> <adjacentRegion rdf:resource="#PomoravljeRegion" /> </Region>

2. Symmetric Property

P(x,y) iff P(y,x)

adjacentRegion is symmetric property


Property Property CharacteristicsCharacteristics

<owl:Class rdf:ID="VintageYear" /> <owl:ObjectProperty rdf:ID="hasVintageYear"> <rdf:type rdf:resource="owl:FunctionalProperty" /> <rdfs:domain rdf:resource="#Vintage" /> <rdfs:range rdf:resource="#VintageYear" /> </owl:ObjectProperty>

3. Functional Property

P(x,y) and P(x,z) implies y=z

hasVintageYear is functional property

One individual of Vintage must have strictly one value of VintageYear.



<owl:ObjectProperty rdf:ID="hasMaker"> <rdf:type rdf:resource="&owl;FunctionalProperty" /> </owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="producesWine"> <owl:inverseOf rdf:resource="#hasMaker" /> </owl:ObjectProperty>

4. InverseOf Property

P(x,y) iff P(y,x)


Ontology MappingOntology Mapping

merging ontologies

hardest part of ontology development

tool support is necessary

Some important OWL primitives:

equivalentClass, equivalentProperty, sameAs,differentFrom, AllDifferent


Equivalent Classes and Equivalent Classes and PropertiesProperties

combined ontologies must not be contradictory

<owl:Class rdf:ID=“o1:caffe"> <owl:equivalentClass rdf:resource=“o2:bar"/>

</owl:Class>

entailments from two ontologies are combined

indicate that two classes have precisely the same instances

To tie together properties in a similar fashion, we use owl:equivalentProperty.

We can use owl:sameAs between two classes to indicate that they are identical in every way (in OWL Full), treating them as individuals.


Identity between Identity between IndividualsIndividuals

sameAs – declaring two individuals to be the same

<Wine rdf:ID="MikesFavoriteWine"> <owl:sameAs rdf:resource="#StGenevieveTexasWhite" /> </Wine>

differentFrom – opposite to sameAs

<WineSugar rdf:ID="Dry" />

<WineSugar rdf:ID="Sweet"> <owl:differentFrom rdf:resource="#Dry"/> </WineSugar>

<WineSugar rdf:ID="OffDry"> <owl:differentFrom rdf:resource="#Dry"/> <owl:differentFrom rdf:resource="#Sweet"/> </WineSugar>

If we erred, and asserted that a wine was both Dry and Sweet, without the differentFrom elements above, this would

imply that Dry and Sweet are identical – contradiction.


Set OperatorsSet Operators intersectionOf<owl:Class rdf:ID="WhiteWine"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Wine" /> <owl:Restriction> <owl:onProperty rdf:resource="#hasColor" /> <owl:hasValue rdf:resource="#White" /> </owl:Restriction> </owl:intersectionOf> </owl:Class>

required element

unionOf<owl:Class rdf:ID="Fruit"> <owl:unionOf rdf:parseType="Collection"> <owl:Class rdf:about="#SweetFruit" /> <owl:Class rdf:about="#NonSweetFruit" /> </owl:unionOf> </owl:Class>

includes both the extensionsSweetFruit & NonSweetFruit

defining members of new class

complementOfselects all individuals that do not belong to a certain class


OWL for ServicesOWL for Services(OWL-S)(OWL-S)


Web Service is a software system identified by a URI

it uses public interfaces and bindings described by Markup Language

definition and function can be discovered by other software systems

software agents exchange information in the form of messages (Request Receive MEP – Message Exchange Pattern)


OWL-S PrimerOWL-S Primer OWL-S uses OWL to define a set of classes and properties specific to the description of a service

OWL-S is designed to perform next tasks:

Task Description

Discovery Locating Web Services.

Invocation Execution of service by an agent or other service.

Interoperation Breaking down interoperability barriers and automatic insertion of message parameter translations.

Composition New services through automatic selection, composition and interoperation of existing services.

Verification Verify service properties.

Execution monitoring

Tracking the execution of composite tasks and identifying failure cases of different exe-traces.


Upper Ontology for Upper Ontology for ServicesServices

OWS-S define a set of classes and properties specific to the description of services.

Service

ServiceModelServiceProfile ServiceGrounding

presentsdescribed by

supports

What does the service provide for and require of agents?

How does it work? How to access to service?


Creating Ontology for Web Creating Ontology for Web ServiceService

1. Describe individual programsDescribe the individual programs that comprise the service. The process model provides a declarative description of a program’s properties.

2. Describe the grounding for each atomic process

3. Describe compositions of the atomic processes Describe the composite process which is a composition of its atomic processes

4. Describe a simple process for a service (optional)

5. Profile descriptionProvide a declarative advertisement for the service.It is partially populated by the process model.


Semantic SearchSemantic Search


Designing a Search Designing a Search AgentAgent

four main phases

1. Initialization agent should setup all variables, structures, and

arrays, method of searching

2. Perceptioncentered on using the knowledge provided to contact a site and

retrieve the information from that location. It should identify if

the target is present and identify paths to other URL 3. Actiondetermines if the goal has been met. If it is not it

has to determine the next step – this is the intelligence of

the agent 4. Effect


Search AlgorithmsSearch Algorithms uniformthose that have no information about number of steps

or the path cost from the current state to the goal – breadth first, depth first… informed

heuristic searches have the information about the goal (estimated path cost to it or step away) best-first, hill-climbing, A*...

How much can we trust that search engine understand what we want ? ?


Using RDF and OWL for Using RDF and OWL for Search EnginesSearch Engines

ontologies are mapping semantically same things

text categorization based on ontology mapping

Comparing each element of an ontology with each element of the other ontology, and than determines a similarity metric.

Example of similarity metric:

),(),(),(

),(

)(

)(),(

BAPBAPBAP

BAP

BAP

BAPBAJaccardsim

Instance is randomly chosen from the universe (A,B).P(A,B) is the probability that the instance belongs to A and B...

similarity with relational databases leads to a global semantic web database


Related links http://www.w3schools.com/default.asp http://www.w3.org

this material was developed with financial help of the wusa fund of austria

Documents