RDF/owl

Transkrypt

RDF/owl

Marcin Skulimowski - RDF
Marcin Skulimowski
Wprowadzenie do Resource Description Framework
I. Podstawy RDF
RDF jest językiem służącym do reprezentacji informacji na temat zasobów w taki sposób aby
informacje te mogły być łatwo przetwarzane przez aplikacje.
Zasoby (Resources)
Zasobem może być wszystko, każda rzecz, każdy obiekt np. książki, samochody, ludzie,
wydawcy etc. Ważne jest aby każdy zasób posiadał identyfiaktor URI (ang. Universal
Resource Identifier – Zunifikowany Identyfikator Zasobów). Identyfikatorem URI może być
wszystko co jednoznacznie identyfikuje dany zasób np.: numer ISBN, numer telefonu
komórkowego. Szczególnym przypadkiem URI jest URL (ang. Universal Resource Locator –
Identyfikator Lokalizacji Zasobów) określony dla zasobów internetowych. Identyfikator URI
nie musi umożliwiać dostępu do zasobu, ma go tylko jednoznacznie identyfikować.
Szczególnym przypadkiem zasobów odgrywających ważną rolę w języku RDF są tzw.
właściwości.
Właściwości (Properties)
Właściwości opisują cechy i właściwości zasobów np.: „zatytułowany”, „napisany przez”,
„należący do”, „w kolorze”. Ponieważ właściwości są także zasobami oznacza to, że są
identyfikowane przez URI (w praktyce często przez URL).
Stwierdzenia o zasobach
Ważnym elementem języka naturalnego są zdania. Zdania oznajmujące informują nas o
pewnych faktach dotyczących występującego w nich podmiotu.
Przykład 1
Rozważmy zdanie
http://xxx.lanl.gov/abs/cs/0610020 ma tytuł „XString: XML as a String”.
W zdaniu tym możemy wyróżnić trzy elementy:
•
•
•
Rzecz, która jest w tym zdaniu opisywana tzn. artykuł.
Właściwość opisywanej rzeczy wyrażona przez ma tytuł.
Wartość właściwości tytuł czyli „XString: XML as a String”.
Można sobie wyobrazić inne stwierdzenia charakteryzujące powyższy artykuł np.
wersja z dn. 2008-04-17
12:11:18
1
http://xxx.lanl.gov/abs/cs/0610020 ma autora, którym jest W. F. Gilreath’a.
http://xxx.lanl.gov/abs/cs/0610020 jest napisany w języku angielskim.
Podstawowa idea języka RDF sprowadza się do założenia, że zasoby można opisywać przy
pomocy stwierdzeń analogicznych do powyższych.
Każde stwierdzenie języka RDF zawiera trzy elementy:
•
podmiot (ang. subject) – zasób (np. osoba, miejsce, rzecz) o którym mówi
stwierdzenie.
•
orzeczenie (ang. predicate) – właściwość (np. nazwa, miasto, tytuł, kolor, kształt,
charakterystyka) podmiotu.
•
obiekt (ang. object) – wartość właściwości opisywanej przez orzeczenie. Obiekt może
być zasobem lub tzw. literałem czyli ciągiem znaków.
Dzięki temu, że właściwości są zasobami mogą być szczegółowo „określone” w
stwierdzeniach w których będą podmiotami. Pozwala to na precyzyjne określenie zależności
między zasobami.
Przykład 2
Zdanie
Artykuł http://xxx.lanl.gov/abs/cs/0610020 ma tytuł „XString: XML as a String”.
może być reprezentowane w języku RDF przez następujące stwierdzenie:
•
•
•
podmiot - http://xxx.lanl.gov/abs/cs/0610020
orzeczenie – http://www.abc.net/elements/tytul
obiekt – „XString: XML as a String”.
Zgodnie z wymogami RDF podmiot i orzeczenie w powyższym stwierdzeniu są
jednoznacznie identyfikowane przez identyfikatory URI. Obiekt jest ciągiem znaków.
Reprezentacja stwierdzeń
Grafy
Podstawową reprezentacją stwierdzeń języka RDF są grafy skierowane. Podmiot i obiekt są
węzłami grafu. Orzeczenie jest krawędzią skierowaną od węzła reprezentującego podmiot do
węzła reprezentującego orzeczenie.
wersja z dn. 2008-04-17
12:11:18
2
Orzeczenie 1
Literał
Podmiot
Orzeczenie 2
Obiekt
Podmioty i obiekty będące zasobami oznaczamy węzłem owalnym. Literały oznaczamy
węzłami w kształcie prostokąta.
Przykład 3
Stwierdzenie z Przykładu 1 ma następującą reprezentację:
http://xxx.lanl.gov/abs/cs/0610020
http://www.abc.net/elements/tytul
”XString: XML as a
String”
Przykład 4
Graf reprezentujący dwa stwierdzenia.
http://www.semantict.net/RDF/introRDF
http://rdf.semantict.net/introRDF/elements#autor
Marcin Skulimowski
http://rdf.semantict.net/introRDF/elements#tytuł
Wprowadzenie do RDF
Notacja N3
Inną reprezentacją języka RDF jest tzw. notacja N3. Stwierdzenie w notacji N3 wygląda
następująco:
<PODMIOT> <ORZECZENIE> <OBIEKT> .
W przypadku gdy OBIEKT jest literałem:
wersja z dn. 2008-04-17
12:11:18
3
<PODMIOT> <ORZECZENIE> ”OBIEKT” .
Rozpatrzmy konkretne przykłady.
Przykład 5
Stwierdzenia z Przykładu 4 możemy przedstawić następująco:
<http://rdf.semantict.net/introRDF> <http://rdf.semantict.net/introRDF/elements#autor> ”Marcin
Skulimowski” .
<http://rdf.semantict.net/introRDF> <http://rdf.semantict.net/introRDF/elements#tytul> ”Wprowadzenie
do RDF” .
Aby uniknąć pisania pełnych identyfikatorów URI możemy używać tzw. QNazw. QNazwa
składa się z prefiksu określającego przestrzeń nazw po którym następuje dwukropek i lokalna
nazwa zasobu. Pełen identyfikator URI otrzymujemy wówczas przez połączenie
identyfikatora URI przestrzeni nazw i nazwy lokalnej zasobu. Stosując QNazwy możemy
pominąć nawias kwadratowy.
Przykład 6
Rozpatrzmy stwierdzenia z Przykładu 5. Przyjmijmy, że prefiks intrdf związany jest z
przestrzenią nazw http://rdf.semantict.net/introRDF/elements#, natomiast prefiks semt związany
jest z przestrzenią nazw http://rdf.semantict.net/. Wówczas powyższe stwierdzenia możemy
zapisać następująco:
@prefix intrdf: http://rdf.semantict.net/introRDF/elements# .
@prefix semt: http://rdf.semantict.net/ .
semt:introRDF
semt:introRDF
intrdf:autor ”Marcin Skulimowski” .
intrdf:tytul ”Wprowadzenie do RDF” .
Zauważmy, że przestrzenie nazw definiujemy przy pomocy @prefix.
Zauważmy, że w stwierdzeniu 1 obiekt czyli autor jest ciągiem znaków. W ten sposób nie
jesteśmy w stanie podać żadnych dodatkowych informacji dotyczących autora np. adres
strony WWW, e-mail etc. (podmiotem stwierdzeń może być tylko zasób!). Jeżeli
chcielibyśmy to zrobić musielibyśmy autora określić jako zasób.
wersja z dn. 2008-04-17
12:11:18
4
Przykład 7
Określmy identyfikator URL autora:
http://www.semantict.net/ludzie/2344
Graf wygląda wówczas następująco:
http://rdf.semantict.net/introRDF/elements#imie
http://rdf.semantict.net/introRDF/elements#wiek
34
Marcin
Powyższym graf reprezentuje następujące stwierdzenia:
semt:introRDF
kto:2344
intrdf:autor
intrdf:imie
kto:2344
kto:2344 .
”Marcin” .
intrdf:wiek ”34” .
gdzie kto oznacza przestrzeń nazw http://www.semantict.net/ludzie/.
W notacji N3 stwierdzenia z tym samym podmiotem możemy zapisać skrótowo rozdzielając
orzeczenie i obiekty średnikiem.
Przykład 8
Stwierdzenia 2 i 3 z przykładu poprzedniego możemy zapisać następująco:
kto:2344
intrdf:imie
”Marcin”; intrdf:wiek ”34” .
Stwierdzenia z tym samym podmiotem i orzeczeniem możemy zapisać skrótowo rozdzielając
obiekty przecinkiem.
Przykład 9
Stwierdzenia
kto:2344
kto:2344
intrdf:autor
intrdf:autor
”Wprowadzenie do RDF” .
”Logika Deskryptywna” .
wersja z dn. 2008-04-17
12:11:18
5
możemy zapisać następująco
kto:2344
intrdf:autor
”Wprowadzeni do RDF”, ”Logika Deskryptywna” .
Aktualny dokument RDF oznaczamy przez <>.
Przykład 10
@prefix intrdf: http://rdf.semantict.net/introRDF/elements# .
<> intrdf:tytul ”Wprowadzenie do RDF”
Puste węzły
W przykładzie 7 aby móc dokładniej scharakteryzować autora określiliśmy dla niego
identyfikator URI dzięki czemu autor stał się zasobem (i w grafie pojawił się nowy węzeł).
Pozwoliło to nam użyć autora jako podmiotu dwóch stwierdzeń (oczywiście stwierdzeń takich
może być więcej). Możemy mieć jednak do czynienia z sytuacją kiedy określanie URI dla
zasobu nie będzie miało sensu np. wtedy gdy nie planujemy odwoływać się do danego zasobu
(w tym przypadku do autora). Może się też zdarzyć, że w chwili tworzenia dokumentu nie
będziemy znali identyfikatora URI dla danego zasobu. W takich przypadkach
wykorzystujemy tzw. puste węzły czyli węzły bez identyfikatorów URI.
Przykład 11
W poniższym grafie autor jest oznaczony pustym węzłem bez identyfikatora URI.
34
Marcin
W notacji N3 puste węzły oznaczamy przez _nazwa. W notacji N3 powyższe stwierdzenia
zapisujemy następująco:
semt:introRDF
intrdf:autor
_:aautor intrdf:imie
_:aautor
_:aautor .
”Marcin” .
wersja z dn. 2008-04-17
12:11:18
6
W notacji N3 (oraz jak zobaczymy w reprezentacji XML) oznaczenie pustego węzła przez
identyfikator ma znaczenie tylko lokalne wewnątrz dokumentu RDF. W przypadku gdy w
dokumencie istnieje kilka pustych węzłów ich różne identyfikatory pozwalają je rozróżnić.
Jeżeli będziemy odwoływać się do danego węzła z zewnątrz (np. z innego dokumentu RDF)
musi on posiadać identyfikator URI.
Przykład 11 obrazuje także inne zastosowanie pustych węzłów. Może się zdarzyć, że wartość
pewnej właściwości nie jest pojedynczym zasobem albo literałem ale jest bardziej złożona. W
powyższym przykładzie taka właściwością jest http://rdf.semantict.net/introRDF/elements#autor.
Wartość tej właściwości określiliśmy jako pusty węzeł, który może być podmiotem innych
stwierdzeń. Dzięki temu możemy ją opisać bardziej szczegółowo.
W notacji N3 puste węzły oznaczmy [].
Przykład 12
Stwierdzenie
”Marcin” .
możemy zapisać następująco
[] intrdf:imie ”Marcin” .
lub
[intrdf:imie ”Marcin”] .
Stwierdzenia
_:aautor
”Marcin” .
Możemy zapisać następująco
[ intrdf:imie ”Marcin” ] intrdf:wiek ”34” .
Stwierdzenie to możemy rozumieć następująco:
Pewna osoba o imieniu Marcin ma 34 lata.
Rozpatrzmy przykład z dwoma pustymi węzłami.
wersja z dn. 2008-04-17
12:11:18
7
Przykład 13
Graf z 3 stwierdzeniami, których podmioty są pustymi węzłami:
Marcin
http://rdf.semantict.net/introRDF/elements#tytul
Wprowadzenie do RDF
Powyższy graf w notacji N3 możemy zapisać następująco:
[ intrdf:imie ”Marcin” ] rdfint:autor [ intrdf:tytul ”Wprowadzenie do RDF” ] .
Stwierdzenie to możemy rozumieć następująco:
Pewna osoba o imieniu Marcin jest autorem pewnej książki pt. „Wprowadzenie do RDF”.
Formuły
Notacja N3 pozwala także na wykorzystywanie stwierdzeń w innych stwierdzeniach.
Przykład 14
Rozważmy stwierdzenie:
semt:introRDF
intrdf:autor
”Marcin Skulimowski” .
Stwierdzenie to może być częścią innego stwierdzenia:
{ semt:introRDF
intrdf:autor
”Marcin Skulimowski } intrdf:informs „Tomek” .
W nawiasie {} możemy umieścić kilka stwierdzeń. Całe wyrażenie w nawiasie {} jest
traktowane jako logiczna koniunkcja zawartych w nim stwierdzeń.
wersja z dn. 2008-04-17
12:11:18
8
Literały z określonym typem danych
W powyższym przykładzie wartością właściwości intrdf:wiek jest literał ”34”. Oczywiście
chodzi nam o liczbę 34, a nie o ciąg znaków ”34”. Co więcej chodzi nam o liczbę 34 w
systemie dziesiętnym. W grafie nie ma jednak o tym żadnej informacji. Informację taką
można umieścić w grafie wykorzystując tzw. literały z określonym typem danych. Literał taki
składa się z ciągu znaków określającego wartość i identyfikatora URI określającego typ
danych.
Przykład 15
Określmy typ danych dla literału z Przykładu 7 określającego wiek:
kto:2344
intrdf:wiek ”34”^^<http://www/w3.org/2001/XMLSchema#integer> .
lub skrótowo używając QNazwy:
kto:2344
intrdf:wiek ”34”^^<xsd:integer> .
gdzie xsd oznacza przestrzeń nazw http://www/w3.org/2001/XMLSchema#.
Graf wygląda następująco:
”34”^^ http://www/w3.org/2001/XMLSchema#integer
W języku RDF nie ma zdefiniowanych typów danych (wyjątek stanowi wbudowany typ
rdf:XMLLiteral). Typy danych wykorzystywane przez RDF są określone przez podanie
odpowiedniego identyfikatora URI. Zwykle są to typy danych wykorzystywane w języku
XML. W powyższym przykładzie wykorzystaliśmy typ integer. Oczywiście w języku RDF
nie istnieje żaden mechanizm sprawdzenia czy dany literał jest rzeczywiście danego typu.
Sprawdzenia takiego mogą ewentualnie dokonywać aplikacje wykorzystujące dokumenty
RDF.
Przykład 16
Rozważmy następujące stwierdzenie
kto:2344
intrdf:wiek ”auto”^^<xsd:integer> .
Oczywiście ciąg znak ”auto” nie jest typem integer. Jednak z punku widzenia języka RDF
stwierdzenie to jest całkowicie poprawne.
wersja z dn. 2008-04-17
12:11:18
9
Literał z informacją w jakim języku jest zapisany
kto:2344
intrdf:imie
”Marcin”@pl .
XML
Reprezentacja stwierdzeń przy pomocy grafów jest wygodna dla ludzi, ale całkowicie
niezrozumiała dla maszyn. Jeżeli język RDF ma być jednym z fundamentów Internetu
semantycznego to musi posiadać reprezentację czytelną dla maszyn. Warunek ten spełnia
notacja N3. Jednak najbardziej popularną i oficjalną (zatwierdzoną przez konsorcjum W3C)
reprezentacją języka RDF jest reprezentacja oparta na języku XML1.
W reprezentacji tej dokument RDF zawarty jest między znacznikami:
<rdf:RDF>

</rdf:RDF>
Jako jeden z atrybutów znacznika RDF podajemy zawsze przestrzeń nazw rdf
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
oraz ewentualnie inne wykorzystywane przestrzenie nazw.
Każdemu stwierdzeniu odpowiada znacznik:
rdf:Description
po którym następuje określenie zasobu (przy pomocy atrybutu elementu rdf:Description)
którego stwierdzenie dotyczy. Określenie to może mieć 3 formy:
•
•
•
atrybut about – gdy określamy istniejący zasób,
atrybut ID – gdy określamy nowy (definiowany) zasób,
bez określenia zasobu – określamy wtedy tzw. zasób anonimowy.
Dowolne stwierdzenie
podmiot, orzeczenie, obiekt .
ma następującą reprezentację w języku XML
<?xml version="1.0"?>
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="PODMIOT">
<ORZECZENIE>OBIEKT</ORZECZENIE>
</rdf:Description>
</rdf:RDF>
1
Notacja N3 jest bardziej ogólna od reprezentacji w XML.
wersja z dn. 2008-04-17
12:11:18
10
Przykład 172
Rozważmy graf z przykładu 3. Stwierdzenie wyrażone tym grafem ma następującą
reprezentację w języku XML
<rdf:RDF
xmlns:pub="http://www.abc.net/publikacje#">
<rdf:Description rdf:about="http://xxx.lanl.gov/abs/cs/0610020">
<pub:tytul>XString: XML as a String</pub:tytul>
</rdf:Description>
</rdf:RDF>
Gdzie pub jest przestrzenią nazw w której zdefiniowana jest właściwość tytul (o
definiowaniu właściwości będzie mowa w części kursu poświęconej RDFS).
Przykład 18
Rozważmy stwierdzenia RDF z przykładu 4. Stwierdzenia te mają następującą reprezentację
w języku XML
<rdf:RDF
xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#">
<rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/">
<intrdf:autor>Marcin Skulimowski</intrdf:autor>
</rdf:Description>
<intrdf:tytul>Wprowadzenie do RDF</intrdf:tytul>
</rdf:Description>
</rdf:RDF>
W powyższych przykładach wartości właściwości opisywanej przez orzeczenie były
literałami.
Przykład 19
Rozważmy teraz bardziej złożony przykład w którym wartość właściwości opisywanej przez
orzeczenie jest zasobem.
2
Wszystkie przykłady z tego rozdziału zostały sprawdzone walidatorem RDF znajdującym się na stronie
konsorcjum W3C: http://www.w3.org/RDF/Validator/
wersja z dn. 2008-04-17
12:11:18
11
http:/www.semantict.net/RDF/introRDF
http://www.semantict.net/RDF/introRDF/elements#autor
http://www.semantict.net/RDF/introRDF/elements#tytul
Marcin Skulimowski
Wprowadzenie do RDF
http://www.semantict.net/RDF/introRDF/elements#czesc
http://www.semantict.net/tech/
http://www.semantict.net/RDF/introRDF/elements#rok
Technologie
Semantyczne
2007
Graf ten reprezentuje następujące stwierdzenia:
<http://www.semantict.net/RDF/introRDF> <http://www.semantict.net/RDF/introRDF/elements#autor>
”Marcin Skulimowski” .
<http://www.semantict.net/RDF/introRDF> <http://www.semantict.net/RDF/introRDF/elements#tytul>
”Wprowadzenie do RDF” .
<http://www.semantict.net/RDF/introRDF> <http://www.semantict.net/RDF/introRDF/elements#czesc>
<http://www.semantict.net/tech/> .
<http://www.semantict.net/tech/> <http://www.semantict.net/RDF/introRDF/elements#rok> ”2007” .
<http://www.semantict.net/tech/> <http://www.semantict.net/RDF/introRDF/elements#tytul>
”Technologie Semantyczne” .
Wykorzystując QNazwy stwierdzenia te możemy w notacji N3 zapisać następująco:
irdf:introRDF intrdf:autor ”Marcin Skulimowski” .
irdf:introRDF intrdf:tytul ”Wprowadzenie do RDF” .
irdf:introRDF intrdf:czesc <http://www.semantict.net/tech/> .
<http://www.semantict.net/tech/> intrdf:rok ”2007” .
<http://www.semantict.net/tech/> intrdf:tytul ”Technologie Semantyczne” .
wersja z dn. 2008-04-17
12:11:18
12
gdzie:
irdf - oznacza przestrzeń nazw http://www.semantict.net/RDF/
intrdf - oznacza przestrzeń nazw http://www.semantict.net/RDF/introRDF/elements#.
Reprezentacja powyższych stwierdzeń w języku XML jest następująca:
<rdf:RDF
</rdf:Description>
<intrdf:tytul>Kurs RDF</intrdf:tytul>
</rdf:Description>
<intrdf:czesc rdf:resource="http://www.semantict.net/tech/"/>
</rdf:Description>
<rdf:Description rdf:about="http://www.semantict.net/tech/">
<intrdf:rok>2007</intrdf:rok>
</rdf:Description>
<intrdf:tytul>Technologie Semantyczne</intrdf:tytul>
</rdf:Description>
</rdf:RDF>
W przykładzie tym wartość właściwości czesc jest zasobem. Stąd odwołanie do zasobu przez
atrybut rdf:resource.
Przykład 20
Zauważmy, że w poprzednim przykładzie obiekt stwierdzenia 3 tzn.
<intrdf:czesc rdf:resource="http://www.semantict.net/tech/"/>
</rdf:Description>
jest podmiotem stwierdzeń 4 i 5 tzn.
</rdf:Description>
</rdf:Description>
wersja z dn. 2008-04-17
12:11:18
13
Orzeczenia związane z tym samym podmiotem można umieścić w jednym elemencie
Description. Ponadto element Description może być wartością właściwości.
<rdf:RDF
<intrdf:tytul>Kurs RDF</intrdf:tytul>
<intrdf:czesc>
</rdf:Description>
</intrdf:czesc>
</rdf:Description>
</rdf:RDF>
Oczywiście taki skrótowy zapis nie zmienia grafu.
Predykaty (orzeczenia)
Jak już wiemy wartością predykatu może być albo zasób albo literał. Zwykle parsery potrafią
rozpoznać czy maja do czynienia z zasobem czy z literałem. Istnieje jednak możliwość
zapisania wprost że wartość predykatu jest zasobem (literałem). Do tego celu
wykorzystywany jest atrybut rdf:parseType.
Przykład 21
Rozważmy następujący fragment przykładu 20:
<intrdf:czesc>
<intrdf:rok rdf:parseType="Literal">
<h1>
2007
</h1>
</intrdf:rok>
<intrdf:tytul>Technologie Semantyczne</intrdf:rok>
</rdf:Description>
</intrdf:czesc>
</rdf:Description>
Dodanie atrybutu rdf:parseType do właściwości intrdf:rok powoduje, że fragment
<h1>2007</h1>
wersja z dn. 2008-04-17
12:11:18
14
jest traktowany jak zwykły ciąg znaków i nie jest parsowany. Metoda ta pozwala umieszczać
fragmenty kodu xml bezpośrednio w plikach rdf/xml. Po tej modyfikacji graf wygląda
następująco:
Marcin Skulimowski
Wprowadzenie do RDF
http://www.semantict.net/tech/
<h1>2007</h1>
Technologie
Semantyczne
Może się zdarzyć, że będziemy mieli do czynienia z zasobem, dla którego ani URI ani URL
nie będziemy znali. W ten sposób nie będziemy mogli określić dla niego ani atrybutu
rdf.about ani rdf:ID. Istnieje jednak możliwość zapisania, że mamy do czynienia z
zasobem. Robimy to przy pomocy atrybutu rdf:parseType nadając mu wartość
"Resource".
Przykład 22
Rozważmy następujący fragment przykładu 6:
<intrdf:czesc rdf:parseType="Resource">
</intrdf:czesc>
</rdf:Description>
wersja z dn. 2008-04-17
12:11:18
15
Marcin Skulimowski
Wprowadzenie do RDF
genid: ARP103321
Technologie
Semantyczne
2007
Zauważmy, że mimo tego, że wartość predykatu czesc nie posiada identyfikatora URI to
jednak jest oznaczona owalem tak jak zasób. Jest to tzw. pusty węzeł. Węzły takie omówimy
w następnym rozdziale.
Atrybutem rdf:parseType można też oznaczyć właściwość będącą zasobem nawet jeżeli
właściwość ta nie posiada wartości.
Przykład 23
Rozważmy następujący przykład:
<rdf:RDF
<intrdf:czesc rdf:parseType="Resource"/>
</rdf:Description>
</rdf:RDF>
Zauważmy, że właściwość czesc nie posiada wartości.
Graf w tym przypadku wygląda następująco:
wersja z dn. 2008-04-17
12:11:18
16
genid: ARP103321
Puste węzły
W poprzednim punkcie mieliśmy do czynienia z sytuacją gdzie URI zasobu nie był określony.
Węzeł związany z takim zasobem nazywamy węzłem pustym (ang. blank node). Pojawienie
się pustego węzła może oznaczać, że identyfikator URI dla danego zasobu nie istnieje lub jest
w danej chwili nieznany. Zasób oznaczony pustym węzłem jest określony przez swoje
własności, a nie przez identyfikator. Pusty węzeł ma zwykle przypisany przez walidator
identyfikator. Dzięki temu, w ramach tego samego dokumentu RDF, puste węzły mogą być
między sobą rozróżnione.
Przykład 24
<rdf:RDF
<intrdf:autor>
<rdf:Description>
<intrdf:imie>Marcin</intrdf:imie>
<intrdf:nazwisko>Skulimowski</intrdf:nazwisko>
</rdf:Description>
</intrdf:autor>
</rdf:Description>
</rdf:RDF>
Graf powyższego dokumentu RDF/XML wygląda następująco
genid:ARP1033
http://www.semantict.net/RDF/introRDF/elements#imie
Marcin
http://www.semantict.net/RDF/introRDF/elements#nazwisko
Skulimowski
wersja z dn. 2008-04-17
12:11:18
17
Walidator wygenerował identyfikator dla pustego węzła będącego wartością właściwości
autor. Identyfikator te nie ma żadnego znaczenia poza tym, że pozwala rozróżnić puste
węzły w ramach tego samego dokumentu RDF. Istnieje możliwość nadania pustemu węzłowi
ściśle określonego identyfikatora. W tym celu wykorzystujemy atrybut rdf:nodeID.
Przykład 25
<rdf:RDF
<intrdf:autor>
<rdf:Description rdf:nodeID="autordane">
</rdf:Description>
</intrdf:autor>
</rdf:Description>
</rdf:RDF>
Graf powyższego dokumentu RDF/XML wygląda następująco:
autordane
http://www.semantict.net/RDF/introRDF/elements#imie
Marcin
http://www.semantict.net/RDF/introRDF/elements#nazwisko
Skulimowski
Uwaga: atrybut rdf:nodeID jest elementem składni RDF/XML i nie jest elementem
abstrakcyjnego modelu RDF.
wersja z dn. 2008-04-17
12:11:18
18
Referencje URI
Względne URI i bazowy URI
Zgodnie z ideą języka RDF wszystkie podmioty i orzeczenia powinny być opisywane
identyfikatorami URI. Nie zawsze musi to jednak być cały identyfikator. Możemy operować
względnym URI. Cały identyfikator URI jest wówczas uzyskany przez połączenie bazowego
URI i względnego URI.
Załóżmy, że dokument http://www.semantict.net/RDF/introRDF/ zawiera następujący
element
<rdf:Description rdf:about="cos">
Bazowym URI jest URI dokumentu zawierającego powyższy element. Pełen identyfikator
URI otrzymujemy przez połączenie URI bazowego i URI względnego tzn.
http://www.semantict.net/RDF/introRDF/cos
Identyfikator URI otrzymujemy w powyższy sposób zawsze wtedy kiedy dla danego zasobu
nie jest podany pełen identyfikator. Możliwe jest też określenie bazowego URI bez względu
na dokument zawierający dany element. Wykorzystujemy w tym celu atrybut xml:base.
Przykład 26
<rdf:RDF
xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"
xml:base="http://www.semantict.net/RDF/">
<rdf:Description rdf:about="introRDF">
<intrdf:autor>
<rdf:Description>
</rdf:Description>
</intrdf:autor>
</rdf:Description>
</rdf:RDF>
Podobnie jak poprzednio pełen identyfikator URI powstaje przez konkatencję (sklejenie)
nazwy z atrybutu about (względny URI) oraz atrybutu xml:base (bazowy URI). W
efekcie otrzymujemy:
Jeżeli w powyższym przykładzie nie określimy atrybutu xml:base wówczas pełen URI jest
otrzymany przez konkatencję adresu pliku zwierającego dokument RDF/XML oraz atrybutu
about.
wersja z dn. 2008-04-17
12:11:18
19
Atrybut rdf:ID
Atrybut rdf:ID jest bardzo podobny do atrybutu rdf:about. Podobieństwo polega na tym,
że oba atrybuty służą do określenia identyfikatora URI. Jednak o ile atrybut rdf:about
określa URI istniejącego zasobu o tyle atrybutu rdf:ID jest używany do określenia nowego
zasobu. Do zasobu takiego możemy się odwoływać przez wartość atrybutu ID prefiksem #.
Przykład 27
<rdf:RDF
<intrdf:autor>
<rdf:Description>
</rdf:Description>
</intrdf:autor>
<intrdf:seria>
<rdf:Description rdf:ID="semtech">
<intrdf:tytul>Technologie Semantyczne</intrdf:rok>
</rdf:Description>
</intrdf:seria>
</rdf:Description>
</rdf:RDF>
Pełen URI dla w powyższym przykładzie uzyskujemy przez połączenie URI bazowego i
wartości atrybutu rdf:ID przedzielonych znakiem # tzn.
http://www.semantict.net/RDF/#semtech
Predykat rdf:value
<intrdf:modyfikacja>23</intrdf:modyfikacja>
Przyjmijmy, że liczba 23 związana jest z ostatnią datą modyfikacji tzn. tyle dni temu zasób
był modyfikowany. Nie wiemy jednak czy chodzi o godziny, dni, czy może miesiące. Taką
dodatkową informację możemy zapisać następująco:
<intrdf:modyfikacja>23 dni</intrdf:modyfikacja>
wersja z dn. 2008-04-17
12:11:18
20
W tym przypadku wydobycie informacji o liczbie dni wymaga jednak rozbicia zawartości
znacznika na dwa elementy: liczba i słowo ‘dni’. Informację taką możemy jednak zapisać
inaczej:
<intrdf:modyfikacja>23</intrdf:modyfikacja>
<intrdf:jednostka>dzien</intrdf:jednostka>
W tym przypadku jednak wartość 23 nie jest ściśle związana z jednostką poza tym, że
modyfikacja i jednostka są właściwościami tego samego zasobu. Powyższych problemów
możemy uniknąć jeżeli zastosujemy predykat rdf:value, który określa właśnie wartość.
Rozważmy przykład:
Przykład 28
<rdf:RDF
<intrdf:modyfikacja>
<rdf:value>23</rdf:value>
<intrdf:jednostka>dzien</intrdf:jednostka>
</intrdf:modyfikacja>
</rdf:Description>
</rdf:RDF>
W przykładzie tym liczba 23 jest wartością właściwości value związanej z zasobem
autordane.
http://www.semantict.net/RDF/introRDF/elements#modyfikacja
genid:ARP1033
http://www.semantict.net/RDF/introRDF/elements#jednostka
dzień
http://www.w3.org/1999/02/22-rdf-syntax-ns#value
23
Predykat rdf:type
Zasoby, którymi zajmowaliśmy się do tej pory nie miały ściśle określonego typu. Były po
prostu zasobami. Możemy jednak określić typ zasobu przy pomocy predykatu rdf:type.
wersja z dn. 2008-04-17
12:11:18
21
Przykład 29
<rdf:RDF
xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements/">
<intrdf:type
rdf:resource="http://www.semantict.net/RDF/introRDF/elements#kurs"/>
</rdf:Description>
</rdf:RDF>
Predykat rdf:type związał dany zasób z klasą kurs określoną w RDFS.
RDF/XML skróty
Istnieje kilka sposobów uproszczenia dokumentu RDF.
•
•
Różne predykaty określające ten sam zasób mogą znajdować się w jednym elemencie
Description (patrz Przykład 20).
Niepowtarzające się właściwości (orzeczenia) można zapisać jako atrybuty zasobu (w
języku XML atrybuty tego samego elementu muszą mieć różne nazwy).
Przykład 30
<rdf:RDF
<rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"
intrdf:autor="Marcin Skulimowski"
intrdf:tytulKurs="RDF"/>
</rdf:RDF>
•
W elemencie Description z określonym typem zasobu zamiast rdf:Description
możemy pisać typ zasobu.
Przykład 31
<rdf:RDF
<intrdf:Kurs rdf:about="introRDF">
<intrdf:autor>
<rdf:Description>
wersja z dn. 2008-04-17
12:11:18
22
</rdf:Description>
</intrdf:autor>
</intrdf:Kurs>
</rdf:RDF>
•
Zasoby, które nie mają orzeczeń nie muszą być zdefiniowane w bloku Description.
W dotychczasowych przykładach zasoby były zawsze określone przy pomocy znacznika
rdf:Description. Blok rdf:Description może być pominięty. Jest to możliwe w
dwóch przypadkach.
1. Dany obiekt będący zasobem nie jest podmiotem żadnego orzeczenia.
Przykład 32
<rdf:RDF
<intrdf:czesc rdf:resource="tech"/>
</rdf:Description>
</rdf:RDF>
Nowy zasób został wprowadzony przy pomocy atrybutu rdf:resource.
2. Zasób jest podmiotem stwierdzenia (stwierdzeń), ale dokładnie opisany jest w
dalszej części dokumentu (i tam są podane związane z nim właściwości i ich
wartości).
Przykład 33
<rdf:RDF
<rdf:Description rdf:about="introRDF.html">
<intrdf:czesc rdf:resource="tech"/>
</rdf:Description>
<rdf:Description rdf:about="tech">
</rdf:Description>
</rdf:RDF>
wersja z dn. 2008-04-17
12:11:18
23
Powyższy zapis można uprościć wykorzystując omówiony wcześniej skrót tzn.
orzeczenia podmiotu będącego zasobem możemy umieścić jako atrybuty znacznika
rdf:Description.
<rdf:RDF
<rdf:Description rdf:about="tech" intrdf:autor="Marcin
Skulimowski" intrdf:rok="2007"/>
</rdf:RDF>
Omówione powyżej skróty upraszczają reprezentację stwierdzeń RDF w języku XML, ale
oczywiście nie zmieniają grafu będącego właściwą reprezentacją języka RDF.
wersja z dn. 2008-04-17
12:11:18
24
Zaawansowane konstrukcje języka RDF
Kontenery
Kontenery są wykorzystywane w sytuacjach kiedy mamy do czynienia ze stwierdzeniami
dotyczącymi wielu różnych zasobów traktowanych jako całość. W języku RDF istnieją trzy
rodzaje kontenerów.
rdf.Bag
Kontener ten zawiera nieuporządkowaną listę zasobów (lub literałów) w której poszczególne
elementy mogą się powtarzać.
Przykład 34
<rdf:RDF
<rdf:Description rdf:about="spis.html">
<intrdf:ksiazki>
<rdf:Bag>
<rdf:li rdf:resource="semanticweb.pdf"/>
<rdf:li rdf:resource="rdf.pdf"/>
<rdf:li rdf:resource="owl.pdf"/>
</rdf:Bag>
</intrdf:ksiazki>
</rdf:Description>
</rdf:RDF>
Graf
http://www.semantict.net/RDF/spis.html
http://www.semantict.net/RDF/introRDF/elements#ksiazki
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
genid:A69811
http://www.w3.org/1999/02/22-rdf-syntax-ns#_1
1
2
3
4
Gdzie:
1 - http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag
2 - http://www.semantict.net/RDF/semanticweb.pdf
3 - http://www.semantict.net/RDF/rdf.pdf
4 - http://www.semantict.net/RDF/owl.pdf
wersja z dn. 2008-04-17
12:11:18
25
Jeżeli kontener zawiera literały zamiast zasobów wówczas każdy element jest określony
następująco
<rdf:li>Internet Semantyczny</rdf:li>
Zamiast elementów rdf:li możemy użyć elementów postaci rdf:_n gdzie n jest liczbą.
Przykład 35
<rdf:RDF
<intrdf:ksiazki>
<rdf:Bag>
<rdf:_1 rdf:resource="semanticweb.pdf"/>
<rdf:_2 rdf:resource="rdf.pdf"/>
<rdf:_3 rdf:resource="owl.pdf"/>
</rdf:Bag>
</intrdf:ksiazki>
</rdf:Description>
</rdf:RDF>
Elementy rdf:_n i rdf:li można użyć jednocześnie przy czym liczba n nie ma wpływu na
numerację w grafie związaną z rdf:li.
Przykład 36
<rdf:RDF
<intrdf:ksiazki>
<rdf:Bag>
</rdf:Bag>
</intrdf:ksiazki>
</rdf:Description>
</rdf:RDF>
wersja z dn. 2008-04-17
12:11:18
26
Graf
http://www.semantict.net/RDF/introRDF/elements#ksiazki
genid:A69811
1
2
3
4
Gdzie:
1 - http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag
2 - http://www.semantict.net/RDF/semanticweb.pdf
3 - http://www.semantict.net/RDF/rdf.pdf
4 - http://www.semantict.net/RDF/owl.pdf
rdf:Seq
Kontener ten zawiera uporządkowaną listę zasobów (lub literałów) w której poszczególne
elementy mogą się powtarzać. A zatem w tym przypadku kolejność odgrywa role i jest
określana za pomocą elementu rdf:_n widocznym na grafie. Wartość tego atrybutu
związana jest z kolejnością elementów listy.
Przykład 37
<rdf:RDF
<intrdf:ksiazki>
<rdf:Seq>
<rdf:li rdf:resource="rdf.pdf"/>
</rdf:Seq>
</intrdf:ksiazki>
</rdf:Description>
</rdf:RDF>
wersja z dn. 2008-04-17
12:11:18
27
W dokumencie RDF/XML możemy użyć elementy rdf:_n.
Przykład 38
<rdf:RDF
<intrdf:ksiazki>
<rdf:Seq>
<rdf:_1 rdf:resource="semanticweb.pdf"/>
<rdf:_3 rdf:resource="owl.pdf"/>
</rdf:Seq>
</intrdf:ksiazki>
</rdf:Description>
</rdf:RDF>
rdf:Alt
Kontener ten zawiera alternatywy dla pewnej wartości. Musi on zawierać przynajmniej jeden
element będący wartością domyślną (pierwszy element listy).
Przykład 39
<rdf:RDF
<rdf:Description rdf:about="kurs.html">
<intrdf:prowadzi>
<rdf:Alt>
<rdf:_1 rdf:resource="11234"/>
<rdf:_2 rdf:resource="34567"/>
</rdf:Alt>
</intrdf:prowadzi>
</rdf:Description>
</rdf:RDF>
W powyższym przykładzie wykład prowadzi osoba o identyfikatorze 11234 lub osoba o
identyfikatorze 34567.
Kolekcje
W przeciwieństwie do kontenerów kolekcja zawiera skończoną liczbę elementów z
zaznaczonym elementem ostatnim. W dokumentach RDF/XML kolekcja jest zdefiniowana
przez atrybut rdf:parseType="Collection".
wersja z dn. 2008-04-17
12:11:18
28
Przykład 40
<rdf:RDF
<intrdf:menu rdf:parseType="Collection">
<rdf:Description rdf:about="semanticweb.pdf"/>
<rdf:Description rdf:about="rdf.pdf"/>
<rdf:Description rdf:about="owl.pdf"/>
</intrdf:menu>
</rdf:Description>
</rdf:RDF>
Graf
http://www.semantict.net/RDF/introRDF/elements#menu
genid:A69811
rdf:first
http://www.semantict.net/RDF/semanticweb.pdf
rdf:rest
genid:A69812
rdf:first
http://www.semantict.net/RDF/rdf.pdf
rdf:rest
genid:A69813
rdf:first
http://www.semantict.net/RDF/owl.pdf
rdf:rest
http://www.w3.org/1999/02/22-rdf-syntax-ns#nil
przy czym użyliśmy następujących skrótów:
rdf:first zamiast http://www.w3.org/1999/02/22-rdf-syntax-ns#first
rdf:rest zamiast http://www.w3.org/1999/02/22-rdf-syntax-ns#rest
wersja z dn. 2008-04-17
12:11:18
29
Reifikacja
Dotychczas rozważaliśmy stwierdzenia składające się z 3 elementów:
podmiot, orzeczenie, obiekt
Przykładem takiego stwierdzenia pochodzącym z języka potocznego jest zdanie
Witrynę http://www.abc.pl stworzył Łukasz
W języku potocznym zdarzają się jednak stwierdzenia bardziej złożone np.:
Marek powiedział, że witrynę http://www.abc.pl stworzył Łukasz
Jest to stwierdzenie dotyczące innego stwierdzenia czyli tzw. metastwierdzenie. Poznane
dotychczas konstrukcje języka RDF nie pozwalają nam formułować stwierdzeń dotyczących
tego stwierdzenia ponieważ stwierdzenie nie jest zasobem i nie może być podmiotem innego
stwierdzenia. Umożliwia to tzw. reifikacja.
Stwierdzenie
Witrynę http://www.strona.pl stworzył Łukasz
będące częścią powyższego zdania ma bardzo prostą reprezentację w języku RDF\XML.
<rdf:Description rdf:about="http://www.strona.pl/">
<intrdf:autor>Łukasz</intrdf:autor>
</<rdf:Description>
Przykład 41
<rdf:RDF
<rdf:Description rdf:about="opinia.html">
<rdf:subject rdf:resource="http://www.strona.pl/"/>
<rdf:predicate
rdf:resource="http://www.semantict.net/RDF/introRDF/elements#autor"/>
<rdf:object>Lukasz</rdf:object>
<rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntaxns#Statement"/>
<intrdf:informs>Tomek</intrdf:informs>
</rdf:Description>
</rdf:RDF>
wersja z dn. 2008-04-17
12:11:18
30
Graf
http://www.w3.org/1999/02/22-rdf-syntax-ns#subject
http://www.strona.pl/
http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate
http://www.semantict.net/RDF/opinia.html
http://www.w3.org/1999/02/22-rdf-syntax-ns#object
Łukasz
http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement
http://www.semantict.net/RDF/introRDF/elements/informs
Tomek
Informacje o reifikowanym stwierdzeniu i reifikacje można rozdzielić. Jest to szczególnie
przydatne gdy stwierdzenie poddane reifikacji jest podmiotem kilku stwierdzeń.
Przykład 42
<rdf:RDF
<rdf:Description rdf:about="#w">
<rdf:subject rdf:resource="http://www.strona.pl/"/>
<rdf:predicate
rdf:resource="http://www.semantict.net/RDF/introRDF/elements#autor"/>
<rdf:object>Łukasz</rdf:object>
<rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntaxns#Statement"/>
</rdf:Description>
<rdf:Description rdf:about="http://www.semantict.net/persons/01">
<intrdf:informsAbout rdf:resource="#w" />
</rdf:Description>
</rdf:RDF>
Reifikacji możemy też dokonać bez używania właściwości subject, predicate i
object. Do właściwości występującej w stwierdzeniu dodajemy wówczas atrybut rdf:ID.
wersja z dn. 2008-04-17
12:11:18
31
Przykład 43
<rdf:RDF
<rdf:Description rdf:about="http://www.strona.pl/">
<intrdf:autor rdf:ID="w">Łukasz</intrdf:autor>
</rdf:Description>
<rdf:Description rdf:about="#w">
<intrdf:informs rdf:resource="http://www.semantict.net/persons/01" />
</rdf:Description>
</rdf:RDF>
RDF i HTML
Język HTML służy do tworzenia stron internetowych. Oprócz informacji i sposobu ich
prezentacji można w dokumentach HTML umieścić pewne metadane. Standardowo robi się
to przy pomocy znaczników <meta>. Można jednak zrobić coś więcej, można dołączyć do
dokumentu HTML dokument RDF ze stwierdzeniami dotyczącymi zasobów. Zgodnie z
zaleceniem W3C można tego dokonać umieszczając w dokumencie HTML link do
odpowiedniego dokumentu RDF.
Przykład 44
<head>
<title>Moja strona</title>
<link rel="meta" type="application/rdf+xml" href="meta.rdf">
</head>
Znacznik <link> nie musi znajdować się w nagłówku dokumentu HTML. Możemy umieścić
go w części <body>.
wersja z dn. 2008-04-17
12:11:18
32
II. Schematy RDF (RDFS)
Język RDFS pozwala nam definiować słownictwo wykorzystywane w dokumentach RDF.
Podstawowymi elementami takiego słownictwa są klasy (ang. class) zasobów i ich
właściwości (ang. property) charakterystyczne dla rozważanej dziedziny.
Klasy i właściwości
Stwierdzenia języka RDF dotyczą konkretnych przykładów obiektów należących do różnych
klas.
Przykład 44
<rdf:RDF
xmlns:pub="http://www.abc.net/publikacje/">
<rdf:Description rdf:about="http://xxx.lanl.gov/abs/quant-ph/0609211">
<pub:tytul>How to Introduce Time Operator</pub:tytul>
<rdf:type rdf:resource="http://www.abc.net/publikacje/artykul"/>
</rdf:Description>
</rdf:RDF>
Zasób http://xxx.lanl.gov/abs/quant-ph/0609211 jest określony jako przykład klasy
http://www.abc.net/publikacje/artykul.
Klasy zasobów charakteryzowane są przez właściwości. Rozważmy następujące stwierdzenie:
Artykuł „How to Introduce Time Operator” został napisany przez „Wprowadzenie do XML” .
Oczywiście stwierdzenie takie nie ma sensu. Obiekt „How to Introduce Time Operator” jest
przykładem klasy artykuł. „Wprowadzenie do XML” jest przykładem klasy książka.
Oczywiście artykuły nie są pisane przez ksiązki. Musimy zatem zagwarantować, aby wartość
właściwości napisany/napisana przez była przykładem klasy autor. Oznacza to, że musimy
określić zasięg (ang. range) tej właściwości. Podobnie musimy określić jej dziedzinę (ang.
domain). W przypadku powyższego zdania dziedzinę stanowi klasa publikacja.
Przestrzeń nazw dla schematów RDF:
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
Język RDFS posiada „wbudowane” pewne klasy i właściwości przy pomocy których możemy
definiować własne klasy i właściwości.
Podstawowe klasy RDF i RDFS
rdfs:Class – klasa wszystkich klas.
wersja z dn. 2008-04-17
12:11:18
33
Przykład 45
Klasę artykul możemy zdefiniować następująco:
<rdfs:Class rdf:ID="Publikacja">

</rdfs:Class>
rdfs:Resource – klasa wszystkich zasobów.
rdfs:Literal – klasa wszystkich literałów (ciągów znaków).
rdfs:XMLLiteral – klasa wszystkich literałów zawierających składnię XML'a. Klasa ta
jest podklasą klasy rdfs:Literal.
rdf:Property – klasa wszystkich zasobów określających właściwości.
Przykład 46
Właściwość tytul możemy zdefiniować następująco:
<rdf:Property rdf:ID="tytul">

</rdf:Property>
rdfs:Datatype – klasa typów danych. Każdy przykład tej klasy jest podklasą klasy
rdfs:Literal.
rdf:Statement – klasa wszystkich reifikowanych stwierdzeń.
rdf:Bag – nieuporządkowana kolekcja.
rdf:Seq – uporządkowana kolekcja.
rdf:Alt – kolekcja alternatyw.
rdfs:Container – klasa kontenerów.
rdf:ConstraintResource - klasa wszystkich więzów.
Klasa rdfs:Class jest podklasą klasy rdfs:Resource tzn. każda klasa jest zasobem.
Klasa rdfs:Resource jest przykładem klasy rdfs:Class ponieważ rdfs:Resource
jest klasą wszystkich zasobów, a zatem jest klasą czyli przykładem rdfs:Class.
wersja z dn. 2008-04-17
12:11:18
34
rdfs:Resource
rdfs:Class
rdfs:ConstraintResource
rdf:Property
rdfs:ConstraintProperty
RDFS – hierarchia podstawowych klas
W definicjach klas i właściwości możemy wykorzystywać następujące właściwości:
Podstawowe właściwości RDF i RDFS
rdf:type - właściwość, która określa klasę do której należy dany zasób. Zasób jest
przykładem tej klasy (patrz Przykład 1).
rdfs:subClassOf - właściwość, która określa klasę (superklasę) w której zawiera się
dana klasa (będąca jej podklasą). Wszystkie przykłady klasy są przykładami superklasy.
Klasa może być podklasą wielu klas.
Przykład 47
Klasa artykul jest podklasą klasy publikacje.
<rdfs:Class rdf:about="Artykul">
<rdfs:subClassOf rdf:resource="#Publikacja"/>
</rdfs:Class>
Przykład 48
Klasa artykulInternetKsiazka artykułów które zostały opublikowane Internecie oraz w postaci
książkowej jest podklasą klasy artykulInternet i klasy artykulKsiazka.
<rdfs:Class rdf:ID="ArtykulInternetKsiazka">
<rdfs:subClassOF rdf:resource="#ArtykulInternet"/>
<rdfs:subClassOF rdf:resource="#ArtykulKsiazka"/>
</rdfs:Class>
rdfs:subPropertyOf - właściwość, która określa właściwość (superwłaściowość) w
której zawiera się dana właściwość (będąca jej podwłaściwością).
wersja z dn. 2008-04-17
12:11:18
35
Przykład 49
<rdf:Property rdf:ID="tytulKsiazki">
<rdfs:subPropertyOf rdf:resource="#tytul"/>
</rdf:Property>
Właściwości rdfs:subClassOf i rdfs:subPropertyOf są przechodnie.
rdfs:domain - określa dziedzinę (ang. domain) właściwości P tzn. klasę zasobów, które
mogą się pojawić jako zasób z właściwością P. Jeżeli dziedzina nie jest określona może nią
być dowolna klasa.
rdfs:range - określa zakres (ang. range) właściwości P tzn. klasę zasobów, które mogą się
pojawić jako wartość właściwości P.
Przykład 50
Wartość właściwość tytul powinna być literałem.
<rdfs:domain rdf:resource="#publikacja"/>
<rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/>
</rdf:Property>
Przykład 51
Wartość właściwość ISSN powinna być liczbą całkowitą.
<rdf:Property rdf:ID="ISSN">
<rdfs:domain rdf:ID="publikacja"/>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/>
</rdf:Property>
rdf:ConstraintProperty - klasa wszystkich właściwości definiujących więzy. Klasa
ta jest podklasą klasy rdf:ConstraintResource i rdf:Property. Klasa ta posiada
dwa przykłady: rdfs:domain i rdfs:range.
rdfs:label – określenie zasobu dla ludzi
Przykład 52
<rdf:Property rdf:ID="ISSN">
<rdfs:label>numer ISSN</rdfs:label>
<rdfs:domain rdf:recource="#publikacja"/>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/>
</rdf:Property>
wersja z dn. 2008-04-17
12:11:18
36
rdfs:seeAlso – własność określająca inny zasób zawierający informacje na temat
opisywanego zasobu.
Przykład 53
<rdf:Description rdf:about="http://www.w3.org/2000/01/rdf-schema#">
<rdfs:seeAlso rdf:resource="http://www.w3.org/2000/01/rdf-schema-more#"/>
</rdf:Description>
rdfs:isDefinedBy - określa przestrzeń nazw zasobu.
rdfs:comment – umożliwia dodanie komentarza
Przykład 54
<rdfs:Class rdf:ID="ArtykulInternetKsiazka">
<rdfs:subClassOF rdf:resource="#ArtykulInternet"/>
<rdfs:subClassOF rdf:resource="#ArtykulKsiazka"/>
<rdfs:comment>
klasa artykułów opublikowanych jednocześnie w Internecie i w
formie książkowej
</rdfs:comment>
</rdfs:Class>
rdfs:member – element kontenera
rdf:first - pierwszy element listy (głowa)
rdf:rest – pozostała część listy (ogon)
rdf:value – określa wartość właściwości
rdf:subject – podmiot stwierdzenia
rdf:predicate – orzeczenie stwierdzenia
rdf:object – obiekt stwierdzenia
wersja z dn. 2008-04-17
12:11:18
37
rdf:Property
rdfs:Resource
rdfs:ConstraintProperty
rdfs:Class
rdf:Literal
rdfs:domain
rdfs:range
rdfs:ConstraintResource
RDFS – zależności między przykładami podstawowych klas i właściwości
wersja z dn. 2008-04-17
12:11:18
38
Przykładowy Schemat RDF
Poniżej schemat RDF związany z publikacjami.
<rdf:RDF
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
<rdfs:Class rdf:ID="Publikacja"/>
<rdfs:domain rdf:resource="#Publikacja"/>
<rdfs:range
rdf:resource="http://www.w3.org/2000/01/rdfschema#Literal"/>
</rdf:Property>
<rdfs:Class rdf:ID="Artykul">
</rdfs:Class>
<rdfs:Class rdf:ID="Ksiazka">
</rdfs:Class>
<rdf:Property rdf:ID="tytulArtykulu">
<rdfs:domain rdf:resource="#Artykul"/>
</rdf:Property>
<rdf:Property rdf:ID="tytulKsiazki">
<rdfs:domain rdf:resource="#Ksiazka"/>
</rdf:Property>
<rdf:Property rdf:ID="issn">
<rdfs:range
rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/>
</rdf:Property>
<rdf:Property rdf:ID="autor">
<rdfs:range
rdf:resource="http://www.w3.org/2000/01/rdfschema#Literal"/>
</rdf:Property>
<rdf:Property rdf:ID="liczbaStron">
<rdfs:range
rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/>
</rdf:Property>
</rdf:RDF>
wersja z dn. 2008-04-17
12:11:18
39
Schematy RDF i notacja N3
Schematy RDF można zapisywać w notacji N3. W notacji N3 właściwość rdf:type ma
skrótową postać a.
Przykłady z poprzedniego rozdziału zapisane w notacji N3:
Przykład 45*
:Publikacja a rdfs:Class .
Przykład 46*
:tytul a rdf:Property .
Przykład 47*
:Artykul a rdfs:Class .
:Artykul rdfs.subClassOf :Publikacja .
Skrótowo:
:Artykul a rdfs:Class; rdfs:subClassOf :Publikacja .
Przykład 48*
:ArtykulInternetKsiazka rdfs:subClassOf :ArtykulInternet, :ArtykulKsiazka .
Przykład 49*
:tytulKsiazki rdfs:subPropertyOf :tytul .
Przykład 50*
:tytul rdfs:domain :publikacja;
rdfs:range <http://www.w3.org/2000/01/rdf-schema#Literal> .
Przykład 51*
:issn rdfs:domain :publikacja;
rdfs:range <http://www.w3.org/2001/XMLSchema#integer> .
Przykład 52*
:issn rdfs:label "numer ISSN";
rdfs:domain :publikacja;
rdfs:range <http://www.w3.org/2001/XMLSchema#integer> .
wersja z dn. 2008-04-17
12:11:18
40
Ograniczenia RDFS
Język RDFS pozwala nam definiować proste ontologie. Posiada jedna pewne ograniczenia:
•
rdfs:range określa zakres właściwości dla wszystkich klas. Ta sama właściwość
może mieć różne zakresy dla różnych klas.
Przykład: zywiSie.
•
Brak możliwości zapisania, że dwie klasy są rozłączne.
Przykład: klasa Kobieta i klasa Mezczyzna.
•
Brak możliwości definiowania klas z użyciem operacji sumy, iloczynu.
Przykład: klasa Osoba jako rozłączna suma klas Kobieta i Mezczyzna.
•
Brak ograniczeń na liczbę wartości które może posiadać dana właściwość.
Przykład: właściwość mama.
•
Brak bardziej szczegółowego określenia właściwości: właściwość przechodnia,
właściwość odwrotna etc.
Przykład:
wyzszyOd,
zjada, jestZjadanyPrzez
Istnieje zatem potrzeba rozszerzenia RDFS. „Rozszerzeniem” takim jest język OWL (ang.
Ontology Web Language).
wersja z dn. 2008-04-17
12:11:18
41
IV. SPARQL
SPARQL (ang. SPARQL Protocol And RDF Query Language) jest językiem zapytań dla
dokumentów RDF. SPARQL pozwala wyciągać z nich dane zawężone według kryteriów
określonych poprzez predykaty RDF. Jest opisany przez kilka specyfikacji W3C. W obecnej
chwili wszystkie specyfikacje są w statusie szkicu. Ostania wersja robocza – 26 marzec 2007.
Zmienne w zapytaniach języka SPARQL oznaczamy przez
?nazwa_zmiennej
Przykład 53
Dane:
<http://example.org/book/book1>
<http://purl.org/dc/elements/1.1/title> "SPARQL Tutorial" .
Zapytanie:
SELECT ?title
WHERE
{
<http://example.org/book/book1>
<http://purl.org/dc/elements/1.1/title> ?title .
}
Wynik:
"SPARQL Tutorial"
Przykład 54
Dane:
@prefix foaf:
_:a foaf:name
_:a foaf:mbox
_:b foaf:name
_:b foaf:mbox
_:c foaf:mbox
<http://xmlns.com/foaf/0.1/> .
"Johnny Lee Outlaw" .
<mailto:[email protected]> .
"Peter Goodguy" .
Zapytanie:
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?name ?mbox
WHERE
{ ?x foaf:name ?name .
?x foaf:mbox ?mbox }
Wynik:
"Johnny Lee Outlaw" <mailto:[email protected]>
wersja z dn. 2008-04-17
12:11:18
42
"Peter Goodguy" mailto:[email protected]
Przykład 55
Dane:
@prefix
@prefix
@prefix
@prefix
:x ns:p
:y ns:p
:z ns:p
dt: <http://example.org/datatype#> .
ns: <http://example.org/ns#> .
: <http://example.org/ns#> .
xsd: <http://www.w3.org/2001/XMLSchema#> .
"cat"@en .
"42"^^xsd:integer .
"abc"^^dt:specialDatatype .
Zapytanie:
SELECT ?v WHERE { ?v ?p "cat"@en }
Wynik:
<http://example.org/ns#x>
Przykład 56
Dane:
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
_:a foaf:name "Alice" .
_:b foaf:name "Bob" .
Zapytanie:
SELECT ?x ?name
WHERE { ?x foaf:name ?name }
Wynik:
_:c "Alice"
_:d "Bob"
Przykład 57
Dane:
Zapytanie:
wersja z dn. 2008-04-17
12:11:18
43
SELECT ?x ?name
WHERE { ?x foaf:name ?name
FILTER regex(?name, "bo", "i" )}
Wynik:
_:c "Bob"
Przykład 58
Dane:
_:a foaf:age 23 .
_:b foaf:age 32 .
Zapytanie:
SELECT ?z
WHERE { ?x foaf:age ?y
FILTER (?y<30)
?x foaf:name ?z }
Wynik:
"Alice"
Przykład 59
Dane:
@prefix dc: <http://purl.org/dc/elements/1.1/> .
@prefix : <http://example.org/book/> .
@prefix ns: <http://example.org/ns#> .
:book1 dc:title "SPARQL Tutorial" .
:book1 ns:price 42 .
:book2 dc:title "The Semantic Web" .
:book2 ns:price 23 .
Zapytanie:
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX ns: <http://example.org/ns#>
SELECT ?title ?price
WHERE { ?x dc:title ?title .
OPTIONAL { ?x ns:price ?price . FILTER (?price < 30) }
}
Wynik:
"SPARQL Tutorial"
"The Semantic Web" 23
wersja z dn. 2008-04-17
12:11:18
44
Zastosowania
1) Dublin Core
http://dublincore.org/ http://www.ukoln.ac.uk/metadata/dcdot/
2) Adobe PDF
3) FOAF http://www.foaf-project.org/
3) RDFpic
http://jigsaw.w3.org/rdfpic/
Aplikacje
4) IsaViz
http://www.w3.org/2001/11/IsaViz/
5) RDF API for PHP http://sites.wiwiss.fu-berlin.de/suhl/bizer/rdfapi/
wersja z dn. 2008-04-17
12:11:18
45
Dublin Core jest ogólnym standardem metadanych służącym do opisu zasobów.
Wersja 1.1 standardu Dublin Core Metadata Element Set określa następujące elementy
metadanych, które mogą być obecne w opisie:
Title (tytuł)
Creator (twórca)
Subject and Keywords (temat i słowa kluczowe)
Description (opis)
Publisher (wydawca)
Contributor (współtwórca)
Date (data)
Resource Type (typ zasobu)
Format (format)
Resource Identifier (identyfikator zasobu)
Source (źródło)
Language (język)
Relation (odniesienie)
Coverage (zakres)
Rights Management (zarządzanie prawami)
Przykład
<rdf:RDF
xmlns:dc="http://purl.org/dc/elements/1.1/">
<rdf:Description rdf:about="http://www.semantict.net">
<dc:title>Wprowadzenie do RDF</dc:title>
<dc:creator>Marcin Skulimowski</dc:creator>
<dc:date>07.05.07</dc:date>
<dc:type>Text</dc:type>
<dc:format>text/html</dc:format>
<dc:format>1873 bytes</dc:format>
<dc:language>pl</dc:language>
<dc:relation>www.semantic-web.org</dc:relation>
</rdf:Description>
</rdf:RDF>
wersja z dn. 2008-04-17
12:11:18
46
Marcin Skulimowski
Wprowadzenie do Ontology Web Language
Ontologie
Ontologia jest pojęciem zaczerpniętym z filozofii, gdzie miedzy innymi oznacza analizę pojęć
i idei w celu ustalenia co istnieje oraz jakie są związki pomiędzy istniejącymi elementami. W
informatyce pojęcia tego używa się w bardzo podobnym kontekście.
Ontologia to formalna specyfikacja konceptualizacji pewnego obszaru wiedzy czy opisu
elementów rzeczywistości.
Przy projektowaniu ontologii wykorzystywane są metody kategoryzacji i hierarchizacji.
Pewnym pojęciom abstrakcyjnym i grupom obiektów posiadającym wspólne cechy
przyporządkowywane są nazwy, tworzone są wiec klasy obiektów (kategoryzacja). Tak
utworzone klasy są następnie umieszczane w strukturze hierarchicznej. Przy tworzeniu
ontologii można użyć różnych języków modelowania. Najczęściej wykorzystywany jest
RDF/RDFS lub bardziej wyrafinowane języki wykorzystujące tą technologię np. OWL.
Wymagania stawiane językom służącym do tworzenia ontologii
Dobrze określona składnia.
Formalna semantyka – semantyka opisująca precyzyjnie wiedzę. Precyzyjnie tzn. bez
subiektywnych intuicji oraz bez możliwość różnych interpretacji przez różne aplikacje.
Skuteczne wnioskowanie
Formalna semantyka pozwala wnioskować na temat wiedzy. W przypadku ontologii możemy
wnioskować o:
•
Przynależności do klasy.
Jeżeli x jest przykładem klasy C i C jest podklasą D wówczas wnioskujemy, że x jest
przykładem D.
•
Równoważności klas.
Jeżeli klasa A jest równoważna klasie B i klasa B jest równoważna klasie C wówczas
klasa A jest równoważna klasie C.
•
Niesprzeczności.
Przypuśćmy, że zadeklarowaliśmy, że x jest przykładem klasy A i klasa A jest podklasą
B∩C, A jest podklasą D, klasy B i D są rozłączne. Otrzymujemy sprzeczność.
•
Klasyfikacji.
Jeżeli zdeklarujemy, że pewne warunki są wystarczające dla przynależności do klasy
A, wówczas jeżeli obiekt x spełnia te warunki, wówczas wnioskujemy, że x jest
przykładem klasy A.
Wnioskowania takie są przeprowadzane automatycznie i pozwalają:
wersja z dn. 2008-04-17
12:11:18
47
•
•
•
Sprawdzić niesprzeczność ontologii.
Automatycznie klasyfikować przykłady klasy.
Uzyskać zależności między klasami, które nie są wprost zapisane w ontologii.
Ontology Web Language
Nagłówek
Dokumenty OWL (nazywamy ontologiami OWL) są dokumentami RDF/XML. Korzeniem
takiego dokumentu jest element RDF którego atrybutami są deklaracje przestrzeni nazw.
Przykład 1
<rdf:RDF
xmlns="http://www.semantict.net/RDF/introRDF/elements#"
xml:base="http://www.semantict.net/RDF/introRDF/elements#"
xmlns:owl="http://www.w3.org/2002/07/owl#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#">
Następnym elementem jest opcjonalny element owl:Ontology, który zawiera pewne
informacje dotyczące ontologii.
Element ten zawiera atrybut rdf:about, którego wartość określa nazwę lub referencję do
ontologii. Wartość "" oznacza, ze opisujemy ontologię znajdującą się w bieżącym
dokumencie.
Reprezentant klasy owl:Ontology (czyli ontologia) posiada następujące właściwości:
•
owl:versionInfo – informacje o wersji ontologii.
•
owl:priorVersion
–
poprzednia
wersji
ontologii
(właściwość
nie
tylko
owl:Ontology).
•
owl:backwardCompatibleWith – określa ontologię, która jest „kompatybilna” z
daną ontologią. Wszystkie konstrukcje występujące w obu ontologiach (klasy,
właściwości etc.) mają to samo znaczenie.
•
owl:incompatibleWith - określa ontologię, która jest nie kompatybilna z daną
ontologią. Niekompatybilność może na przykład oznaczać, że zmieniło się określenie
jednej z klas.
•
owl:imports – określa identyfikator URI ontologii, które są przyjmowane jako
część aktualnej ontologii.
Jeżeli ontologia A importuje ontologię B oznacza to, że w ontologii A są wszystkie
klasy i właściwości określone przez B.
wersja z dn. 2008-04-17
12:11:18
48
•
owl:imports jest właściwością przechodnią. Jeżeli ontologia A importuje ontologię
B i ontologia B importuje ontologię C wówczas ontologia A importuje ontologię C.
Przykład 2
<owl:Ontology rdf:about="">
<rdfs:label>Ontologia Uniwersytetu</rdfs:label>
<owl:versionInfo>Pierwsza wersja ontologii zwiazanej z
uniwersytetem</owl:versionInfo>
<owl:priorVersion
rdf:resource="http://www.semantict.net/OWL/07/uni-old/"/>
<owl:backwardCompatibleWith
<owl:incompatibleWith
<owl:imports rdf:resource="http://www.domain.com/uni"/>
Klasy
W języku OWL istnieją dwie wbudowane klasy:
owl:Thing – klasa zwierająca wszystkie klasy.
owl:Nothing – klasa pusta zawierająca się w każdej klasie.
Własne klasy definiujemy przy pomocy elementu owl:Class. Klasa owl:Class jest
podklasą klasy rdfs:Class.
Przykład 3
<owl:Class rdf:ID=”Profesor”>
<rdfs:subClassOf rdf:resource=”#kadraAkademicka”/>
<owl:Class>
W języku OWL możemy powiedzieć, że dwie klasy są rozłączne. Używamy w tym celu
właściwości owl:disjointWith.
Przykład 4
<owl:Class rdf:about=”#Profesor”>
<rdfs:disjointWith rdf:resource=”#Adiunkt”/>
<rdfs:disjointWith rdf:resource=”#Asystent”/>
</owl:Class>
Możemy też powiedzieć, że jedna klasa jest równoważna z inną klasą. Służy do tego
właściwość owl:equvalentClass.
wersja z dn. 2008-04-17
12:11:18
49
Przykład 5
<owl:Class rdf:about=”#Adiunkt”>
<rdfs:equivalentClass rdf:resource=”#Doktor”/>
</owl:Class>
Właściwości
W języku OWL istnieją dwa rodzaje właściwości:
•
właściwości obiektowe (owl:ObjectProperty) – łączą obiekty z obiektami.
Przykład 6
<owl:ObjectProperty rdf:ID=”jestProwadzonyPrzez”>
<rdfs:domain rdf:resource=”#Wyklad”/>
<rdfs:range rdf:resource=”#Profesor”/>
</owl:Class>
•
właściwości typów danych (owl:DatatypeProperty) – łączą obiekty ze
standardowymi typami danych (np. z XMLSchema)
Przykład 7
<owl:DatatypeProperty rdf:about=”#rokStudiow”>
<rdfs:domain rdf:resource=”#Student”/>
<rdfs:range
rdf:resource=”http://www.w3.org/2001/XMLSchema#integer”/>
</owl:Class>
Właściwość owl:inverseOf służy do określenia właściwość będącej odwrotnością innej
właściwości.
Przykład 8
<owl:ObjectProperty rdf:about=”#prowadziWyklad”>
<rdfs:domain rdf:resource=”#Profesor”/>
<rdfs:range rdf:resource=”#Wyklad”/>
<owl:inverseOf rdf:resource=”#jestProwadzonyPrzez”/>
</owl:Class>
Podobnie jak w przypadku klas możemy powiedzieć, że dwie właściwości są równoważne.
Służy do tego właściwość owl:equivalentProperty.
Przykład 9
<owl:ObjectProperty rdf:ID=”#wyklada”>
<owl:equivalentProperty rdf:resource=”#prowadziWyklad”/>
wersja z dn. 2008-04-17
12:11:18
50
</owl:ObjectProperty>
Ograniczenia właściwości
Załóżmy, że chcemy powiedzieć, że wszyscy reprezentanci klasy C spełniają pewne warunki
(oprócz wieli innych). Możemy to zrobić twierdząc, że klasa C jest podklasą klasy C’ której
wszyscy reprezentanci spełniają te warunki.
Klasa C’ nie ma identyfikatora (jest anonimowa) i jest określona przez podanie warunków
jakie spełniają jej elementy.
Warunki te są związane z ograniczeniami nałożonymi na właściwości. Ograniczenie
właściwości określamy następująco:
<owl:Restriction>
<owl:onProperty rdf:resorce=”nazwa_wlasciwosci”/>
sposób_ograniczenia
</owl:Restriction>
Właściwości możemy ograniczać na kilka sposobów.
Ograniczenia wartości
owl:allValuesFrom – określa dopuszczalne wartości właściwości.
Przykład 10
<owl:Class rdf:about=”wykladNaPierwszymRoku”>
<owl:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resorce=”#jestProwadzonyPrzez”/>
<owl:allValuesFrom rdf:resorce=”#Profesor”/>
</owl:Restriction>
</owl:subClassOf>
</owl:Class>
Klasa wykladNaPierwszymRoku obejmuje wykłady, które są prowadzone przez
przedstawicieli klasy Profesor.
UWAGA: nie oznacza to, że każdy przedstawiciel klasy wykladNaPierwszymRoku musi
mieć określonego prowadzącego profesora. Jeżeli jednak ma właściwość
jestProwadzonyPrzez to jej wartość musi być typu Profesor.
wersja z dn. 2008-04-17
12:11:18
51
owl:someValuesFrom – przynajmniej jedna wartość właściwości musi być danego typu.
Przykład 11
<owl:Class rdf:about=”#Profesor”>
<owl:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resorce=”#prowadziWyklad”/>
<owl:someValuesFrom rdf:resorce=”#wykladMonograficzny”/>
</owl:Restriction>
</owl:subClassOf>
</owl:Class>
Oznacza to, że każdy reprezentant klasy Profesor musi prowadzić przynajmniej jeden
wykład monograficzny (reprezentant klasy wykladMonograficzny).
owl:hasValue – określa dokładną wartość właściwości.
Przykład 12
<owl:Class rdf:about=”#wykladMatematyka”>
<owl:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resorce=”#jestProwadzonyPrzez”/>
<owl:hasValue rdf:resorce=”#787678”/>
</owl:Restriction>
</owl:subClassOf>
</owl:Class>
Oznacza to, że wykład z matematyki jest prowadzony przez osobą o identyfikatorze 787678.
Ograniczenia kardynalne
Ograniczenia takie pozwalają nam określić ile wartości może posiadać dana właściwość.
owl:minCardinality – minimalna liczba wartości.
owl:maxCardinality – minimalna liczba wartości.
owl:Cardinality – dokładna liczba wartości.
wersja z dn. 2008-04-17
12:11:18
52
Przykład 13
<owl:Class rdf:about=”#WykladOpcjonalny”>
<owl:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resorce=”#uczestniczy”/>
<owl:minCardinality
rdf:datatype=”http://www.w3.org/2001/XMLSchema#nonNegativeInteger”/>
10
</owl:minCardinality>
</owl:Restriction>
</owl:subClassOf>
</owl:Class>
Specjalne właściwości
•
owl:TransitiveProperty – właściwość przechodnia.
Przykład: jestWyzszyOd, jestNastepca.
•
owl:SymmetricProperty – właściwość symetryczna.
Przykład: jestTegoSamegoWzrostu, jestBratem.
•
owl:FunctionalProperty – właściwość która może posiadać co najwyżej
jedna wartość.
Przykład: wiek, wzrost, numerISSN.
•
owl:inverseFunctionalProperty – właściwość która dla dwóch różnych
obiektów nie może posiadać tej samej wartości.
Przykład: numerPesel, numerTelefonu.
Przykład 14
<owl:ObjectProperty rdf:ID=”studiujeNaTymSamymRokuCo”>
<rdf:type rdf:resource=”&owl;TransitiveProperty”/>
<rdf:type rdf:resource=”&owl;SymmetricProperty”/>
<rdfs:domain rdf:resource=”#Student”/>
<rdfs:range rdf:resource=”#Student”/>
</owl:ObjectProperty>
wersja z dn. 2008-04-17
12:11:18
53
Operacje Boolowskie
W języku OWL możliwe definiowanie klas przy pomocy operacji Boolowskich.
owl:unionOf – określamy klasę będącą sumą innych klas.
Przykład 15
<owl:Class rdf:ID=”skladOsobowyUniwersytetu”>
<owl:unionOf rdf:parseType=”Collection”>
<owl:Class rdf:about=”#kadraAkademicka”/>
<owl:Class rdf:about=”#Student”/>
</owl:unionOf>
</owl:Class>
owl:interSectionOf – określamy klasę będącą sumą innych klas.
Przykład 16
<owl:Class rdf:ID=”AdunkciWydzialuMatematyki”>
<owl:interSectionOf rdf:parseType=”Collection”>
<owl:Class rdf:about=”#OsobyZeStopniemDoktora”/>
<owl:Class rdf:about=”#PracownicyWydzialuMatematyki”/>
</owl:unionOf>
</owl:Class>
owl:complementOf – określamy klasę będącą dopełnieniem innej klasy.
Przykład 16
<owl:Class rdf:ID=”pracownicyAdministracji”>
<owl:subClassOf>
<owl:Class>
<owl:complementOf rdf:resource=”pracownicyNaukowi”/>
</owl:Class>
</owl:subClassOf>
</owl:Class>
wersja z dn. 2008-04-17
12:11:18
54
Wyliczanie
Za pomocą elementu owl:oneOf możemy określić klasę wypisując jej wszystkie elementy.
Przykład 17
<owl:Class rdf:ID=”DniTygodnia”>
<owl:oneOf rdf:parseType=”Collection”>
<owl:Thing rdf:about=”#Poniedzialek”/>
<owl:Thing rdf:about=”#Wtorek”/>
<owl:Thing rdf:about=”#Sroda”/>
<owl:Thing rdf:about=”#Czwartek”/>
<owl:Thing rdf:about=”#Piatek”/>
<owl:Thing rdf:about=”#Sobota”/>
<owl:Thing rdf:about=”#Niedziela”/>
</owl:oneOf>
</owl:Class>
Przykłady klas
Klasy zdefiniowane w ontologii możemy wykorzystywać w dokumentach RDF.
Przykład 18
<rdf:Description rdf:ID=”949352”>
<rdf:type rdf:resource=”#kadraAkademicka”/>
<rdf:Description>
Równoważnie
Przykład 19
<kadraAkademicka rdf:ID=”949352”/>
Oczywiście do określenia klasy możemy dodać orzeczenia.
Przykład 20
<kadraAkademicka rdf:ID=”949352”>
<uni:prowadziWyklad>Matematyka Dyskretna</uni:prowadziWyklad>
</kadraAkademicka>
W języku OWL dwa obiekty (przykłady) klasy mające różne identyfikatory lub nazwy nie
muszą być różnymi obiektami.
wersja z dn. 2008-04-17
12:11:18
55
Przykład 21
<owl:ObjectProperty rdf:ID=”jestProwadzonyPrzez”>
<rdfs:domain rdf:resource=”#Wyklad”/>
<rdfs:range rdf:resource=”#Profesor”/>
<rdf:type rdf:resource=”&owl;FunctionalProperty”/>
</owl:Class>
<Wyklad rdf:ID=”w234”>
<jestProwadzonyPrzez rdf:resource=”#789098”>
<jestProwadzonyPrzez rdf:resource=”#675899”>
</Wyklad>
Powyższy fragment ontologii nie prowadzi aplikacji wnioskującej do sprzeczności ponieważ
nie jest powiedziane, że profesor o ID 789098 nie jest profesorem o ID 675899.
Informacje o tym, że dwa przykłady klasy są różne musimy zapisać wprost.
Przykład 22
<Profesor ID=”789098”>
<owl:differentFrom rdf:resource=”#675899”/>
</Profesor>
Przykład 23
<owl:AllDifferent>
<owl:distinctMembers rdf:parseType=”Collection”>
<lecturer rdf:about=”#789098”/>
</owl:distinctMembers>
</owl:AllDifferent>
wersja z dn. 2008-04-17
12:11:18
56
Dialekty OWL
OWL Full – wszystkie konstrukcje języka mogą być stosowane.
OWL DL – spełnia następujące warunki:
•
podział słownictwa – każdy zasób może być jedynie: klasą, typem danych,
właściwością, przykładem klasy lub częścią wbudowanego słownictwa.
Oznacza to, że np. klasa nie może być jednocześnie przykładem klasy. Podobnie
właściwość nie może posiadać pewnych wartości będących typami danych i pewnych
będących przykładami klas.
• Typy zasobów muszą być pisane wprost.
Przykład 24
<owl:Class rdf:ID=”C1”>
<rdfs:SubClassOf rdf:about=”#C2”/>
</owl:Class>
Możemy wywnioskować, że zasób C2 jest klasą. W OWL DL musi to być jednak
zapisane wprost:
<owl:Class rdf:ID=”C2”/>
•
Zbiory właściwości obiektowych i właściwości typów danych są rozłączne.
•
Właściwości przechodnie nie mogą być ograniczane kardynalnie.
•
Anonimowe klasy są dozwolone jedynie jako dziedzina i
oraz owl:disjointWith, i jako
owl:equivalentClass
rdfs:subClassOf.
zakres
zakres
OWL Lite – spełnia warunki OWL DL oraz warunki:
•
Zakazane jest użycie konstruktorów: owl:oneOf, owl:disjointWith,
owl:unionOf, owl:complementOf i owl:hasValue.
•
W ograniczeniach kardynalnych właściwości można stosować tylko liczby 0 i 1.
•
Właściwość owl:equivalentClass nie być użyta dla anonimowych klas.
wersja z dn. 2008-04-17
12:11:18
57
wersja z dn. 2008-04-17
12:11:18
58
Reguły wnioskowania w notacji N3.
Aby móc wnioskować w oparciu o RDF i OWL musimy dysponować regułami np.
{ :termostat :temp :wysoka} log:implies { :podgrzewanie :moc ”0” } .
W formułach mogą występować zmienne, które mogą przyjmować wartości różnych
obiektów. Możliwe są dwa rodzaje zmiennych.
Zmienne uniwersalne
Zmienną uniwersalną deklarujemy następująco:
@forAll :x
Przykład 1
Rozważmy regułę:
@forAll :x.
{ :termostat :temp :x } log:implies { :chlodzenie :moc :x } .
Reguła ta mówi, że jeżeli temperatura jest x wówczas moc chłodzenia wynosi x.
Zmienne egzystencjalne
Zmienną egzystencjalną deklarujemy następująco:
@forSome :x
wersja z dn. 2008-04-17
12:11:18
59
Przykład 2
Rozważmy regułę:
@forSome :a.
:Tomek :dom :a .
:a :telefon ”4566778” .
Reguła ta mówi, że istnieje coś takiego jak dom Tomka i ma numer telefonu 4566778.
Zauważmy, że możemy to zapisać inaczej:
:Tomek :dom [ :telefon ”4566778” ] .
Puste węzły są zmiennymi egzystencjalnymi.
Przykład 3
Stwierdzenia:
[ intrdf:imie ”Marcin” ] intrdf:wiek ”34” .
Możemy zapisać równoważnie:
@forSome :a.
:a intrdf:imie ”Marcin” .
:a intrdf:wiek ”34” .
Podobnie stwierdzenia:
[ intrdf:imie ”Marcin” ] intrdf:autor [ intrdf:tytul ”Wprowadzenie do RDF” ] .
możemy zapisać:
@forSome :a.
@forSome :b.
:a intrdf:imie ”Marcin” .
:a intrdf:autor :b .
:b intrdf:tytul ”Wprowadzenie do RDF” .
Zmienne z ? i _
W niektórych sytuacjach
egzystencjalnych.
nie
musimy
wprowadzać
zmiennych
uniwersalnych
i
Zamiast zmiennej uniwersalnej możemy użyć ?x.
Przykład 4
Regułę:
@forAll :x, :y.
{ :x :rodzic :y } log:implies { :y :dziecko :x } .
wersja z dn. 2008-04-17
12:11:18
60
Możemy zapisać następująco:
{ ?x :rodzic ?y } log:implies { ?y :dziecko ?x } .
Zamiast zmiennej uniwersalnej możemy użyć _:x.
Przykład 5
Stwierdzenia:
@forSome :x, :y.
:x :kocha :y . :y :niekocha :x .
Możemy zapisać następująco:
_:x :kocha _:y . _:y :niekocha _:x .
Możemy też korzystać z [] pomijając zmienne egzystencjalne w ogóle.
Konstrukcje i reguły w RDF i RDFS
W opisywanych regułach będziemy korzystali z następujących przestrzeni nazw.
@prefix log: <http://www.w3.org/2000/10/swap/log#>.
@prefix math: <http://www.w3.org/2000/10/swap/math#>.
@prefix list: <http://www.w3.org/2000/10/swap/list#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix : <http://eulersharp.sourceforge.net/2003/03swap/rpo-rules#>.
Definicje RDF i OWL
Definicje wszystkich konstrukcji używanych w językach RDF, RDFS i OWL możemy
zapisać w notacji N3.
owl:ObjectProperty rdfs:subClassOf rdf:Property.
owl:OntologyProperty rdfs:subClassOf rdf:Property.
owl:Restriction rdfs:subClassOf owl:Class.
rdfs:subClassOf a rdf:Property;
rdfs:domain rdfs:Class;
rdfs:range rdfs:Class;
a owl:TransitiveProperty.
wersja z dn. 2008-04-17
12:11:18
61
rdfs:subPropertyOf a rdf:Property;
rdfs:domain rdf:Property;
rdfs:range rdf:Property;
a owl:TransitiveProperty.
rdf:first a rdf:Property;
rdfs:domain rdf:List.
rdf:rest a rdf:Property;
rdfs:domain rdf:List;
rdfs:range rdf:List.
owl:equivalentClass a rdf:Property;
rdfs:range rdfs:Class;
rdfs:subPropertyOf rdfs:subClassOf;
a owl:SymmetricProperty.
owl:equivalentProperty a rdf:Property;
rdfs:domain rdf:Property;
rdfs:range rdf:Property;
rdfs:subPropertyOf rdfs:subPropertyOf;
owl:sameAs a rdf:Property;
a owl:SymmetricProperty, owl:TransitiveProperty.
owl:inverseOf a rdf:Property;
rdfs:domain owl:ObjectProperty;
rdfs:range owl:ObjectProperty;
owl:differentFrom a rdf:Property;
owl:distinctMembers a rdf:Property;
rdfs:domain owl:AllDifferent;
owl:oneOf a rdf:Property;
owl:intersectionOf a rdf:Property;
owl:unionOf a rdf:Property;
wersja z dn. 2008-04-17
12:11:18
62
owl:complementOf a rdf:Property;
rdfs:range rdfs:Class.
owl:allValuesFrom rdfs:domain owl:Restriction;
rdfs:range rdfs:Class.
owl:hasValue rdfs:domain owl:Restriction;
rdfs:range rdfs:Resource.
owl:maxCardinality rdfs:domain owl:Restriction;
rdfs:range xsd:nonNegativeInteger.
owl:minCardinality rdfs:domain owl:Restriction;
rdfs:range xsd:nonNegativeInteger.
Wnioskowanie
Aplikacje analizujące w oparciu o dokumenty RDF i OWL wykorzystują m.in. następujące
reguły wnioskowania3:
•
{?S ?P ?O} => {?P a rdf:Property}.
Przykład 6
Ze stwierdzenia:
semt:introRDF
intrdf:autor
kto:2344 .
wynika, że zasób intrdf:autor jest właściwością czyli:
intrdf:autor a rdf:Property .
•
{?P rdfs:domain ?C. ?S ?P ?O} => {?S a ?C}.
Przykład 7
Ze stwierdzeń:
:tytul rdfs:domain :Publikacja .
:2344 :tytul ”XPath and SPARQL” .
3
http://www.agfa.com/w3c/euler/owl-rules.n3 http://www.agfa.com/w3c/euler/rpo-rules.n3
wersja z dn. 2008-04-17
12:11:18
63
wynika, że zasób :2344 jest reprezentantem kasy :Publikacja czyli:
:2344 a :Publikacja .
•
{?P rdfs:range ?C. ?S ?P ?O} => {?O a ?C}.
•
{?A rdfs:subClassOf ?B. ?S a ?A} => {?S a ?B}.
Przykład 8
Ze stwierdzeń:
:Artykul rdfs.subClassOf :Publikacja .
:2344 a :Artykul .
wynika, że zasób :2344 jest reprezentantem klasy :Publikacja czyli:
:2344 a :Publikacja .
•
{?P rdfs:subPropertyOf ?R. ?S ?P ?O} => {?S ?R ?O}.
Przykład 9
Ze stwierdzeń:
:tytulKsiazki rdfs:subPropertyOf :tytul .
:2344 :tytulKsiazki ”XPath and SPARQL” .
wynika, że zasób :2344 ma tytul ”XPath and SPARQL” czyli:
:2344 :tytul ”XPath and SPARQL” .
•
{?X owl:sameAs ?Y. ?P a rdf:Property. ?X ?P ?O} => {?Y ?P ?O}.
Przykład 10
Ze stwierdzeń:
:2344 owl:sameAs :4567 .
:tytulKsiazki a rdf:Property .
wynika, że zasób :4567 ma tytul ”XPath and SPARQL” czyli:
•
{?X owl:sameAs ?Y. ?S ?X ?O} => {?S ?Y ?O}.
wersja z dn. 2008-04-17
12:11:18
64
•
{?X owl:sameAs ?Y. ?P a rdf:Property. ?S ?P ?X} => {?S ?P ?Y}.
•
{?P owl:inverseOf ?Q. ?S ?P ?O} => {?O ?Q ?S}.
•
{?P a owl:SymmetricProperty. ?S ?P ?O} => {?O ?P ?S}.
Przykład 11
Ze stwierdzeń:
:wspolpracownik a owl:SymmetricProperty .
:8878 :wspolpracownik :9876 .
Wynika, że
:9876 :wspolpracownik :8878 .
•
{?P a owl:TransitiveProperty. ?S ?P ?X. ?X ?P ?O} => {?S ?P ?O}.
Przykład 12
Ze stwierdzeń:
:jestStarszyOd a owl:TransitiveProperty .
:8878 :jestStarszyOd :9876 .
:9876 :jestStarszyOd :1000 .
Wynika, że
:8878 :jestStarszy :1000 .
•
{?P a owl:FunctionalProperty. ?S ?P ?X. ?S ?P ?Y} => {?X owl:sameAs ?Y}.
Przykład 13
Ze stwierdzeń:
:mama a owl:FunctionalProperty .
:1000 :mama :3453 .
:1000 :mama :1234 .
Wynika, że
:3453 :sameAs :1234 .
•
{?P a owl:InverseFunctionalProperty. ?X ?P ?O. ?Y ?P ?O} => {?X owl:sameAs ?Y}.
Przykład 14
Ze stwierdzeń:
wersja z dn. 2008-04-17
12:11:18
65
:issn a owl:InverseFunctionalProperty .
:4567 :issn ”23435677” .
:3433 :issn ”23435677” .
Wynika, że
:4567 :owlSameAs :3433 .
•
{?A owl:distinctMembers ?D. ?D rdf:rest ?R} => {?A owl:distinctMembers ?R}.
•
{?A owl:distinctMembers ?D. ?L :subListOf ?D. ?L rdf:first ?X; rdf:rest ?R. ?Y list:in ?R} => {?X
owl:differentFrom ?Y}.
•
{?C owl:oneOf ?L. ?X list:in ?L} => {?X a ?C}.
•
{?C owl:intersectionOf ?L. ?X :inAllOf ?L} => {?X a ?C}.
Przykład 15
Ze stwierdzeń:
:2345 owl:intersectionOf { :a, :b } .
:3456 :inAllOf { :a, :b } .
Wynika, że
:3456 a :2345 .
•
{?A rdfs:subClassOf ?B. ?B rdfs:subClassOf ?A} => {?A owl:equivalentClass ?B}.
•
{?A owl:onProperty ?P, ?Q; owl:hasValue ?V. ?P @has rdfs:domain ?A; a
owl:FunctionalProperty. ?Q rdfs:domain ?D; a owl:FunctionalProperty} => {?P
rdfs:subPropertyOf ?Q}.
Reguły prowadzące do sprzeczności:
•
{?B owl:onProperty ?P1; owl:someValuesFrom ?X. ?X @has owl:intersectionOf ?L. ?L :item
?I1. ?I1 owl:onProperty ?P2; owl:someValuesFrom owl:Thing. ?L :item ?I2. ?I2 owl:onProperty
?P3; owl:someValuesFrom owl:Thing. ?L :item ?I3. ?I3 owl:onProperty ?P2;
owl:allValuesFrom ?C. ?L :item ?I4. ?I4 owl:onProperty ?P3; owl:allValuesFrom ?U. ?U2
owl:onProperty ?P2; owl:someValuesFrom owl:Thing. ?U @has owl:equivalentClass ?U2. ?L
:item ?I5. ?I5 owl:onProperty ?P3; owl:allValuesFrom ?V. ?V2 owl:onProperty ?P3;
owl:someValuesFrom owl:Thing. ?V @has owl:equivalentClass ?V2. ?L :item ?I6. ?I6
owl:onProperty ?P3; owl:allValuesFrom ?W. ?W2 owl:onProperty ?P2; owl:allValuesFrom ?C.
?W @has owl:equivalentClass ?W2. ?C @has owl:equivalentClass ?C1. ?C1 owl:onProperty
?P8; owl:allValuesFrom ?C2. ?P8 owl:inverseOf ?P2. ?D2 owl:onProperty ?P7;
owl:allValuesFrom ?C3. ?P7 owl:inverseOf ?P3. ?C2 @has owl:equivalentClass ?D2. ?D3
owl:onProperty ?P9; owl:allValuesFrom ?C4. ?P9 owl:inverseOf ?P1. ?C3 @has
owl:equivalentClass ?D3. ?C4 owl:complementOf ?A. ?P3 a owl:TransitiveProperty. ?D
rdfs:subClassOf ?A, ?B}
=> {?D owl:equivalentClass owl:Nothing}.
wersja z dn. 2008-04-17
12:11:18
66
•
{?C1 @has owl:equivalentClass ?A. ?A owl:onProperty ?P1; owl:someValuesFrom ?C6. ?P1
@has rdfs:domain ?C1; @has rdfs:range ?C6; @has rdf:type owl:FunctionalProperty. ?C1
@has owl:equivalentClass ?B. ?B owl:onProperty ?P3; owl:someValuesFrom ?C5. ?P3 @has
rdfs:domain ?C1; @has rdfs:range ?C5; @has rdf:type owl:FunctionalProperty. ?C5 @has
owl:equivalentClass ?C. ?C owl:onProperty ?P2; owl:someValuesFrom ?C6. ?P2 @has
rdfs:domain ?C5; @has rdfs:range ?C6; @has rdf:type owl:FunctionalProperty. ?C5 @has
owl:equivalentClass ?D. ?D owl:onProperty ?P7; owl:cardinality ?X1. ?P7 owl:inverseOf ?P3.
?C6 @has owl:equivalentClass ?F. ?F owl:onProperty ?P8; owl:cardinality ?X2. ?P8
owl:inverseOf ?P2. ?C6 @has owl:equivalentClass ?H. ?H owl:onProperty ?P9; owl:cardinality
?X3. ?P9 owl:inverseOf ?P1. ?H @has owl:equivalentClass ?I. ?I owl:onProperty ?P4;
owl:someValuesFrom ?C3. ?P4 @has rdfs:domain ?C6; @has rdfs:range ?C3; @has rdf:type
owl:FunctionalProperty. ?C3 @has owl:equivalentClass ?G. ?G owl:onProperty ?P6;
owl:maxCardinality ?X4. ?P6 owl:inverseOf ?P4. (?X1 ?X2) math:product ?X. ?X
math:notEqualTo ?X3}
=> {?C3 owl:equivalentClass owl:Nothing}.
wersja z dn. 2008-04-17
12:11:18
67

RDF/owl

Transkrypt

Podobne dokumenty

Bison - parsing

Sieć Semantyczna i Ontologie

tutaj - JUG Poznań

laboratorium 2 Linki do przydatnych aplikacji na stronie 2. Zadanie 1

Semantic Web

CKTR121XL - CK International Polska

Zadanie 1

Internet Semantyczny – zadania Zasady uzyskania zaliczenia – na