Cursuri Web Semantic Si Ontologii

Universitatea Ovidius Constanta
Facultatea de Matematica si Informatica
Web semantic si ontologii

Curs 1
Coordonator curs: Conf. univ. dr. Crenguta M. Puchianu
2021
CUPRINS
 Resurse. URI
 Web semantic. Metadate
 Microdate
 Standardul JSON
 Conf. univ. dr. Crenguta Puchianu

Resurse. URI
Resursele sunt informatii ce pot fi gasite pe Web. Aceste informatii
pot fi grupate intr-o pagina web sau un fragment al unei pagini web
si pot descrie entitati ale lumii reale.
Numele unei resurse trebuie sa fie global si sa fie identificat unic in
Web printr-un URI (Uniform Resource Identifier) sau IRI
(Internationalized Resource Identifier).
Multimea URI-urilor se impart in doua categorii:
URL (Uniform Resource Locator)
URN (Uniform Resource Name)
Orice adresa URL are urmatorul format:
“https://” <server> [“:” <port>][<cale_absoluta> [“?”
<interogare>]][#<eticheta>]

Web semantic
Web-ul semantic reprezinta o extensie a Web-ului in care informatia
este inteleasa si procesata de catre calculator, astfel incat acesta sa
poata efectua cautari si combinatii de date pentru a furniza rezultate
corecte, rapide fara un ajutor semnificativ din partea utilizatorului.
Conceptul a fost introdus de catre Tim Berners-Lee si W3C (World

Wide Web Consortium) definit printr-un web al informatiilor in care:
 informatia Web are o semantica exacta, bine stabilita;
 informatia Web poate fi inteleasa si procesata de catre calculator;
 calculatoarele pot integra informatii de pe Web.
Ideea este ca web semantic permite calculatoarelor sa schimbe
informatii intre ele fara sa fie constranse de vreun limbaj de
programare sau de locatia in care se afla informatiile.

Metadate
O soluţie posibila este de a adnota paginile web cu metadate, care sa
furnizeze calculatoarelor date suplimentare pe care sa le citeasca si sa
le proceseze si astfel sa inteleaga continutul acestor pagini web.
De exemplu, metadatele unei pagini web ar putea fi: titlul paginii,
autorul ei, data la care a fost creata, etc.
schema.org este un standard de metadate (vocabular), ce contine o

multime de concepte:
CreativeWork, Book, Movie, MusicRecording, Recipe, TVSeries,
AudioObject, ImageObject, VideoObject, Event, Organization, Person,
Place, LocalBusiness, Restaurant, Product, Offer, AggregateOffer,
Review, AggregateRating, etc
Adresa: https://schema.org/docs/gs.html
Microdate
O microdata este un tag HTML care adnoteaza un alt tag
HTML existent intr-o pagina web.
Tag Semantica
HTML
itemscope Specifica faptul ca secventa care urmeaza este o

descriere a unui anumit element
itemtype Descriem o instanta a conceptului dat ca valoare a

acestui tag
itemprop Fiecare concept se caracterizeaza printr-o serie de

atribute a caror valoare trebuie sa fie specificata.
Aceste proprietati sunt valori ale atributului itemprop

Descrierea datelor unei carti cu
microdate
<div itemscope itemtype="https://schema.org/Book">
<h1>Palatul chelfanelii</h1>
<div itemprop="author" itemscope itemtype="http://schema.org/Person">
Autor: <span itemprop="name"> Pascal Bruckner</span><br>
Locul nasterii: <span itemprop="birthPlace">Franta</span>
</div> <br>
<span>Gen: </span>
<span itemprop="genre"> Ghid de studiu</span><br>
<span> ISBN: </span>
<span itemprop="isbn">9789737078865</span><br>
<span> Numar pagini: </span>
<span itemprop="numberOfPages">128</span><br>
Informatii despre carte gasiti la pagina:

<a href="https://ro.wikipedia.org/wiki/Palatul_chelf%C4%83nelii">Wikipage
</a></div>
Standardul JSON
Javascript Object Notation – format independent de limbaj ce exprima
datele unui obiect ca o lista de proprietati cuprinsa intre { }. Fiecare
proprietate are forma:
numeProprietate:valoare
Oricare valoare este de un anumit tip de date.
JSON lucreaza cu urmatoarele tipuri de date: Integer, Number (pentru
numere reale), String, Boolean (true sau false), Array (o lista cuprinsa
intre [] ce contine una sau mai valori de un anumit tip. Valorile sunt
separate prin virgula ), Object, Null
Exemplu. Sa scriem un program care afiseaza datele unui obiect
Persoana in format JSON.
Implementare Java
Microdatele unei pagini Web pot fi citite şi folosite ȋn aplicaţii
implementate de exemplu cu Java.
Exemplul 2: Să scriem un program care citeşte proprietăţile
conceptului Person care joaca rolul de autor in cazul cartii
“Palatul chelfanelii”, crează un obiect clasei Persoana şi
afisează datele obiectului ȋn două formate: cel definit ȋn
metoda toString() şi JSON.
Solutie:
Pasi de implementare
Pasul 1. Pentru a scrie programul trebuie mai intai să
descărcăm sub formă de arhive:
 HTMLUnit: https://sourceforge.net/projects/htmlunit/
 Jackson ObjectMapper care poate, printre alte
funcţionalităţi, să creeze obiecte JSON din obiecte Java:
com.fasterxml.jackson.databind.ObjectMapper
Pasul 2. Creăm un proiect Java ȋntr-un IDE (de exemplu,
NetBeans) şi importăm fisierele jar ale celor două arhive
descărcate la pasul anterior.
Pasul 3. Scriem clasa Persoana
Pasul 4. Scriem clasa CitireMicrodata
Pasul 5. Scriem clasa TestMicrodata
Alte exercitii
Exercitiul 1. Să se realizeze o pagina HTML care foloseste
microdate pentru a descrie restaurantul “Pescaria lui Matei.
Takeaway”.
Exercitiul 2. Să se scrie un program care citeşte proprietăţile
instantei conceptului Restaurant, crează un obiect clasei
Restaurant şi afisează datele obiectului ȋn două formate: cel
definit ȋn metoda toString() şi JSON.

Diagrama de clase a programului

Curs 2
2021
CUPRINS
 Standardul JSON-LD
 Arhitectura Web-ului semantic
 Standardul RDF
 Documente RDF
 Scrierea si citirea documentelor RDF

Standardul JSON-LD
JSON-LD (JavaScript Object Notation – Linked Data) este un format
bazat pe JSON pentru formatarea si serializarea datelor. Formatul a
fost standardizat de consorţiul W3C ȋn 2010.
JSON-LD introduce următoarele cuvinte cheie:
Cuvȃnt cheie Semnificaţie

@context defineşte contextul folosirii instanţei conceptului
descris. Valoarea lui poate fi vocabularul folosit:
schema.org
@type specifică conceptul de care aparţine instanţa (resursa)
descrisă
@id specifică identificatorul URI al grafului
@graph Conţinutul grafului păstrat ca vector

Exemplu
<script type="application/ld+json">
{ "@context":"http://schema.org",
"@type":"Book",
"name":"Palatul chelfanelii",
"genre":"Ghid de studiu",
"isbn":"9789737078865",
"numberOfPages":128,
"author":{
"@type":"Person",
"name": "Pascal Bruckner",
"birthPlace": "Franta"
}
}</script>
JSON-LD (cont.)
O secvenţă JSON-LD poate fi verificată folosind:
https://search.google.com/structured-data/testing-tool
O secvenţă JSON-LD poate fi citită şi analizată de către programe

scrise de exemplu, ȋn Java.
Pas 1. Creăm un proiect java folosind NetBeans
Pas 2. Adaugăm următoarele librării ca arhive Java:
 gson-2.8.2.jar
 schema-org-client-1.0.0.jar
 jsoup-1.13.1.jar
 guava-28.0-jre.jar
 guava-gwt-28.0-jre.jar
Pas 3. Scriem clasa AplicatieJSON

Arhitectura Web semantic
Standardul RDF (Resource Description
Framework)
RDF este un standard publicat de W3C si poate fi
folosit pentru a reprezenta informatii/cunostinte (resurse)
astfel incat pot fi folosite de catre aplicatii si procesate intr-o
maniera scalabila.
RDF trateaza numai doua aspecte ale semanticii:
asignarea proprietatilor lucrurilor (resurselor) si legarea
resurselor intre ele.
RDF are un model de date abstract folosit pentru a
descrie cunostinte/informatii despre lume. RDF foloseste
acest model pentru a descompune cunostintele/informatiile
in liste de afirmatii.

Triplete RDF
Orice afirmatie are forma:
Subiect-Predicat-Obiect
Afirmatia spune ca relatia are loc (este adevarata) intre
lucrurile denotate de subiectul si obiectul afirmatiei. Un
predicat este o relatie (numita si proprietate) care leaga
lucrurile denotate de subiectul si obiectul afirmatiei.
Cum afirmatia contine numai aceste componente, se mai
numeste si triplet.
Modelul de date al lui RDF se bazeaza pe un graf ce
descrie triplete RDF. Directia arcului este intotdeauna spre
Obiect.
Predicat
Subiect Obiect
Triplete RDF. Reguli
Subiectul poate fi o resursa identificata URI sau un nod blank.
Predicatul trebuie sa fie o resursa identificata URI.
Obiectul poate fi o resursa identificata URI, un nod blank sau un
literal.
Un nod blank este un nod unic ce poate fi folosit in una sau mai
multe afirmatii RDF, dar nu are nume intrinsec.
Nodurile blank se numesc resurse anonime (fara URI). Nodurile blank
furnizeaza o modalitate de a modela relatii n-are in modelele RDF.
Literalele sunt folosite pentru a identifica valori cum ar fi numere si
date prin intermediul unei reprezentari lexicale.
Un literal poate fi obiectul unei afirmatii, dar nu subiectul sau
predicatul unei afirmatii.
Triplete RDF. Exemple
Structura unui document RDF
Un document RDF este reprezentat de un document XML

(deci poate incepe cu declaratia: <?xml version=”1.0”?>) cu
tag-ul <rdf:RDF> </rdf:RDF>. Tag-ul de intrare are ca
atribute cel putin spatiul de nume al vocabularului RDF:
xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-
syntax-ns#”
Alte spatii de nume refera alte vocabulare de metadate =
vocabulare XML folosite pentru descrierea unor tipuri de
resurse.
Exemple: FOAF, DOAP, EARL, W3C Geo, Doublin Core
Metadata Initiative, QUDT (acronim pentru Quantities, Units,
Dimensions and Data Types in OWL and XML)

Conceptele vocabularului RDF
Termeni rdf:RDF, rdf:Description, rdf:ID, rdf:about,
sintactici rdf:parseType, rdf:resource, rdf:li, rdf:nodeID,
rdf:datatype
Nume de rdf:Seq, rdf:Alt, rdf:Bag, rdf:Statement,
clase rdf:Property, rdf:XMLLiteral, rdf:List
Nume de rdf:subject, rdf:predicate, rdf:object, rdf:type,
proprietati rdf:value, rdf:first, rdf:rest, rdf:_n, unde n este un
numar intreg strict pozitiv
Nume de rdf:nil
resurse
Corectitudinea unui document RDF poate fi verificata folosind

serviciul de la adresa:
http://www.w3.org/RDF/Validator/

Exemplu. O resursa de tip Persoana
<?xml version="1.0"?>
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:foaf="http://xmlns.com/foaf/0.1/">
<foaf:Person rdf:ID="p1">
<foaf:name> Puchianu Crenguta </foaf:name>
<foaf:homepage rdf:resource="http://fmi.univ-ovidius.ro"/>
<foaf:mbox rdf:resource="mailto:crenguta.puchianu@univ-ovidius.ro"/>
<foaf:publications rdf:resource="http://math.univ-ovidius.ro/doc/CVpdf/
cv_C_Bogdanro.pdf"/>
</foaf:Person>
</rdf:RDF>

Generarea documentelor RDF cu Jena
Jena - API implementat în Java pentru dezvoltarea

aplicatiilor Web semantice. Poate fi descarcat si instalat de la
adresa: http://jena.apache.org/download/index.cgi.
Documentatia poate fi gasita la adresa:

http://jena.apache.org/documentation/javadoc/jena/
Pentru a folosi Jena, trebuie să importam arhivele jar ale

acestui API in libraria fiecarui pachet sau modificam valoarea
variabilei classpath ca sa le refere.

Clase si metode Jena pentru generarea
specificatiilor RDF
Nume element programare Java Descriere

Model Graf RDF in memorie
ModelFactory Clasa utilitara ce creeaza modele la
cerere
Resource Interfata ce descrie o resursa RDF
Resource createResource(String uri) Creeaza o noua resursa a modelului
curent cu adresa transmisa ca
parametru
void addProperty(String nume, adauga resursei curente proprietatea
String val) nume cu valoarea v
void write(OutputStream oos, String Scrie specificatia pe un flux de iesire,
format) intr-un anumit format specificat ca al
doilea parametru: "RDF/XML-ABBREV”,
"JSON-LD”, etc.

Exemple
1. Scrierea unei clase care afiseaza specificatia RDF a persoanei
Puchianu Crenguta, avand urmatoarele proprietati:
1. Email: Crenguta.puchianu@univ-ovidius.ro
2. Pagina web: http://math.univ-ovidius.ro/
3. Lista de publicatii se gaseste la adresa:
http://math.univ-ovidius.ro/doc/CVpdf/cv_C_Bogdanro.pdf
2. Scrierea unui program care genereaza si afiseaza specificatia RDF

a oricarui obiect al clasei Persoana.
Master: Medii virtuale multi-modale distribuite

Curs 3
2021
CUPRINS
 Legarea resurselor in RDF
 Folosirea mai multor vocabulare in RDF
 Definirea relatiilor in RDF
 Descrierea colectiilor de resurse RDF
 Limbajul SPARQL
 Programe Java pentru interogari SPARQL

Legarea resurselor in RDF
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
<rdf:Description rdf:ID="p2">
<foaf:publications>https://math.univ-
ovidius.ro/doc/CVpdf/cv_DM_Popoviciro.pdf</foaf:publications>
<foaf:homepage>https://www.univ-ovidius.ro</foaf:homepage>
<foaf:mbox>mailto:dmpopovici@univ-ovidius.ro</foaf:mbox>
<foaf:lastName>Popovici</foaf:lastName>
<foaf:firstName>Mircea</foaf:firstName>
<rdf:type>
<foaf:Person/>
</rdf:type>
</rdf:Description>
<foaf:knows>p2</foaf:knows>
<foaf:publications>http://math.univ-
ovidius.ro/doc/CVpdf/cv_C_Bogdanro.pdf</foaf:publications>
<foaf:homepage>https://www.univ-ovidius.ro</foaf:homepage>
<foaf:mbox>mailto:crenguta.puchianu@univ-ovidius.ro</foaf:mbox>
<foaf:lastName>Puchianu</foaf:lastName>
<foaf:firstName>Crenguta</foaf:firstName>
<rdf:type>
<foaf:Person/>
</rdf:type>
</rdf:Description>
</rdf:RDF>
Diagrama UML de clase
Folosirea mai multor vocabulare
Afirmatia: Localitatea in care ma aflu este Constanta
<rdf:RDF
xmlns:db="http://dbpedia.org/page/"
<foaf:based_near>
https://dbpedia.org/page/Constan%C8%9Ba
</foaf:based_near>
<rdf:type> <foaf:Person/> </rdf:type>
</rdf:Description>
</rdf:RDF>
public class ModelRDF {
private static ModelRDF instanta;
private Model model;
private int id;
private Resource r;
private ModelRDF(){
model= ModelFactory.createDefaultModel();
model.setNsPrefix("foaf","http://xmlns.com/foaf/0.1/");
model.setNsPrefix("db", "https://dbpedia.org/page/");
}
public Resource adaugaPersoana(Persoana p){
id++;
r=model.createResource("#p"+id,model.createResource(FOAF.Person))
.addProperty(FOAF.firstName, p.getPrenume())
.addProperty(FOAF.lastName, p.getNume())
.addProperty(FOAF.mbox, p.getEmail())
.addProperty(FOAF.homepage, p.getAdresaPagina())
.addProperty(FOAF.publications, p.getAdresaCV());
return r; }
public void adaugaLocalitate(String loc){
r.addProperty(FOAF.based_near,model.getNsPrefixURI("db")+loc);
}
public void scrieSpecificatieRDF(){model.write( System.out, "RDF/XML-ABBREV" ); }
public static ModelRDF getInstanta() { if(instanta==null) instanta=new ModelRDF();
return instanta; }}
Exemplu
Descrierea revistei Taifasuri folosind RDF:
http://www.taifasuri.ro/
prin urmatoarele elemente: titlu, tip, fondator, editori,
producator (publisher)
Definirea proprietatilor/relatiilor in
RDF
Afirmatia: Eu detin calculatorul Lenovo
(https://www.lenovo.com/ro/ro/laptops/c/Laptops)
de la adresa:
https://4.grgs.ro/images/products/1/1703884/1718464/normal/15-
v130-ikb-fhd-procesor-intel-core-i5-7200u-3m-cache-up-to-310-ghz-
4gb-ddr4-1tb-radeon-530-2gb-freedos-iron-grey-
7b02bbeffe4af55031ca0c059df70c00.jpg
Calculatorul cantareste 2 kg.

Definirea proprietatilor/relatiilor in
<rdf:RDF
RDF (cont.)
xmlns:unit="http://www.qudt.org/qudt/owl/1.0.0/unit/Instances.html/"
xmlns:base="http://www.univ-ovidius.ro/"
<rdf:Description rdf:about="https://4.grgs.ro/images/products/1/1703884/1718464/normal/15-
v130-ikb-fhd-procesor-intel-core-i5-7200u-3m-cache-up-to-310-ghz-4gb-ddr4-1tb-radeon-530-
2gb-freedos-iron-grey-7b02bbeffe4af55031ca0c059df70c00.jpg">
<unit:Kilogram>http://www.qudt.org/qudt/owl/1.0.0/unit/Instances.html#Kilogram</unit:Kilogra
m>
<base:greutate rdf:datatype="http://www.w3.org/2001/XMLSchema#long"> 2</base:greutate>
<rdf:type>https://www.lenovo.com/ro/ro/laptops/c/Laptops</rdf:type>
</rdf:Description>
<base:detine>v130-ikb-fhd-procesor-intel-core-i5-7200u-3m-cache-up-to-310-ghz-4gb-ddr4-
1tb-radeon-530-2gb-freedos-iron-grey-7b02bbeffe4af55031ca0c059df70c00.jpg</base:detine>
<rdf:type>
<foaf:Person/>
</rdf:type>
</rdf:Description>
</rdf:RDF>
Diagrama UML de clase
Definirea colectiilor in RDF
<rdf:RDF
xmlns:base="http://www.univ-ovidius.ro/">
<rdf:Description rdf:about="http://www.univ-ovidius.ro/Programe">
<rdf:type>
<rdf:List/>
</rdf:type>
</rdf:Description>
<rdf:Description>
<rdf:rest rdf:parseType="Collection">
<rdf:Description rdf:about="http://math.univ-ovidius.ro/doc/ProgrameAnalitice/MI1102.pdf"/>
</rdf:rest>
<rdf:first rdf:resource="http://math.univ-ovidius.ro/doc/ProgrameAnalitice/MI1103.pdf"/>
</rdf:Description>
</rdf:RDF>
public class ModelRDF2 {
private static ModelRDF2 instanta; private Model model; private int id; private Resource r;
private ArrayList<String> lista;
private ModelRDF2(){
model= ModelFactory.createDefaultModel();
model.setNsPrefix("base","http://www.univ-ovidius.ro/");
}
public void citesteFisier(){
lista=new ArrayList<>();
try{
BufferedReader br=new BufferedReader(new FileReader("ProgrameAnalitice.txt"));
String linie;
while((linie=br.readLine())!=null) lista.add(linie);
}catch(IOException e){e.printStackTrace();}
}
public void scrieSpecificatieRDF(){
Resource r=model.createResource(model.getNsPrefixURI("base")+"Programe");
r.addProperty(RDF.type, model.createResource(RDF.List));
RDFList listaRDF = model.createList(model.createResource(lista.get(0)));
for(int i=1; i<lista.size(); i++) listaRDF.add(model.createResource(lista.get(i)));
model.write( System.out, "RDF/XML-ABBREV" );
}
public static ModelRDF2 getInstanta() {
if(instanta==null) instanta=new ModelRDF2();
return instanta;
}
}
Definirea colectiilor in RDF (cont.)
 <rdf:Bag>– descrie un container de resurse sau literale

care nu sunt ordonate.
 Container-ul poate contine elemente duplicat.
 Are un atribut optional rdf:ID care identifica si poate fi
referit container-ul.
 Elementele unui container sunt referite prin rdf:_n, n>0
sau rdf:li
Exemplu: Completarea descrierii revistei Taifasuri cu

urmatoarelor elemente: editorii revistei, subiecte tratate si
formatul revistei.
Definirea colectiilor in RDF (cont.)
 <rdf:Seq>– descrie un container de resurse sau literale

ordonate.
 Container-ul poate contine aparitii multiple.
 Are un atribut optional rdf:ID care identifica si poate fi
referit container-ul.
 Elementele unui container sunt referite prin rdf:_n, n>0
sau rdf:li
Exemplu: Scrierea unui program Java care genereaza o

specificatie RDF ce contine o colectie ordonata formata din
numele in ordine alfabetica a cursantilor la cursul WSO.
(Tema)
Limbajul SPARQL
Simple Protocol and RDF Query Language (SPARQL) este un limbaj
de interogare a datelor RDF. A devenit o recomandare a W3C in
2013.
Este similar cu limbajul SQL: selecteaza date ale setului de date
interogat folosind o instructiune Select pentru a determina ce subset
a datelor selectate este furnizat in urma executarii interogarii.
Forma generala:
PREFIX //prefix: URL al spatiului de nume folosit
SELECT //setul de date rezultat
//SELECT DISTINCT
FROM //setul de date in care se cauta
WHERE {//triplet RDF}
Obs. Pot fi folositi modificatorii: ORDER BY, LIMIT nr

Variabilele unei interogari sunt identificatori prefixati de ?. Variabilele
Interogare SPARQL
Care sunt numele persoanelor descrise in documentul Persoane.rdf?
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>"
SELECT ?nume
WHERE {
?p foaf:lastName ?nume
}
----------------------
Rezultatul interogarii
--------------
| nume |
==============
| "Puchianu" |
| "Popovici" |
--------------
Program Java
public class InterogareSparql {
public static void main(String[] args){
Model model = ModelFactory.createDefaultModel();
InputStream is=FileManager.get().open("Persoane.rdf");
if(is!=null) model.read(is, null);
String interogare = "PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> "+
"PREFIX foaf: <http://xmlns.com/foaf/0.1/>"+
"SELECT ?nume "+
"WHERE { "+
"?p foaf:lastName ?nume "+
"}";
Query q = QueryFactory.create(interogare);
System.out.println("----------------------");
System.out.println("Rezultatul interogarii");
QueryExecution qe = QueryExecutionFactory.create(q, model);
ResultSet rezultat = qe.execSelect();
ResultSetFormatter.out(System.out, rezultat, q);
qe.close();
}}
Interogare SPARQL cu
mai multe clauze
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?nume ?prenume
WHERE {
?p foaf:lastName ?nume .
?p foaf:firstName ?prenume
}
//program Java
"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> "+
"PREFIX foaf: <http://xmlns.com/foaf/0.1/>"+
"SELECT ?nume ?prenume "+
"WHERE { "+
"?p foaf:lastName ?nume ."+
"?p foaf:firstName ?prenume"+
"}";

Curs 4. RDF Schema
2021
CUPRINS
 RDF Schema. Concepte de baza
 Definirea claselor in RDFS
 Definirea unei taxonomii in RDFS
 Definirea proprietatilor si a subproprietatilor
 Interogari SPARQL

Limbajul RDFS
Concept Definitie Sintaxa
Tot ceea ce este descris de catre RDF rdfs:Resource
Resursa reprezinta o resursa. O resursa poate fi o
clasa, dar poate fi si o instanta a unei clase.
Clasa corespunde conceptului general de tip rdfs:Class
sau categorie. O clasa furnizeaza un
mecanism abstractizat pentru gruparea
Clasa
resurselor care au caracteristici similare.
Fiecare clasa are asociata o multime de
indivizi, numiti instante ale clasei.
Proprietatea ofera o modalitate de a exprima rdf:Property
Proprietate relatiile intre clase si instantele lor sau
supraclase.
O subclasa X a unei alte clase Y are rdfs:subClassOf
proprietatea ca fiecare instanta a lui X este
si instanta a clasei Y. Se mai spune ca Y
Subclasa
subsumeaza pe X.
Relatia este tranzitiva.
Definirea claselor in RDFS
<rdf:RDF
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:base="http://math.univ-ovidius.ro/">
<rdfs:Class rdf:about=“http://math.univ-ovidius.ro/Persoana”
/>
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Animal" />
</rdf:RDF>
Exercitiu. Sa scriem un program Java care genereaza

specificatia RDF anterioara
Definirea relatiei de subsumare
intre clase in RDFS
Definitie. Clasa A subsumeaza clasa B daca si numai daca multimea
instantelor clasei A include multimea instantelor clasei B.
Daca ?B rdfs:subClassOf ?A si ?x rdf:type ?B atunci ?x rdf:type ?A .
Afirmatia: Orice caine este un animal.
Specificatie RDF:
<rdf:RDF
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Caine">
<rdfs:subClassOf>Animal</rdfs:subClassOf>
</rdfs:Class>
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Animal"/>
</rdf:RDF>
Definirea unei taxonomii in RDFS
<rdf:RDF
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/MasinaDeMarcat">
<rdfs:subClassOf>SistemDeCalcul</rdfs:subClassOf>
</rdfs:Class>
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Abac">
</rdfs:Class>
</rdf:RDF>
Definirea unei taxonomii in RDFS
(cont.)
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/
SistemDeCalcul"/>
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Desktop">
<rdfs:subClassOf>MasinaDeCalculElectronica</rdfs:subClassOf>
</rdfs:Class>
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Laptop">
</rdfs:Class>
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/
MasinaDeCalculElectronica">
</rdfs:Class>
Concepte RDFS (cont.)
Concept Definitie Sintaxa
Daca o proprietate p1 este o rdfs:subPropertyOf
subproprietate a unei proprietati p2 si
daca o resursa A are proprietatea p2
Subproprietate
avand asignata valoarea B, atunci
resursa A are de asemenea
proprietatea p1 cu valoarea B.
Restrictia de domeniu este o rdfs:domain
Domeniu proprietate ce specifica faptul ca orice
(Restrictie de resursa care are o proprietate data este
domeniu) o instanta a uneia sau mai multor
clase.
Restrictia de codomeniu este o rdfs:range
Codomeniu proprietate ce specifica faptul ca
(Restrictie de valorile unei proprietati sunt instante
codomeniu) ale uneia sau mai multor clase.
Literal Defineste un literal rdfs:literal

Definirea proprietatilor in RDFS
O proprietate P poate fi definita cu un domeniu si/sau un range.
Afirmatii:
P rdfs:domain D
P rdfs:range R
Semantica: Proprietatea P leaga instantele clasei D de instantele
clasei R:
Daca P rdfs:domain D si x P y implica x rdf:type D.
Daca P rdfs:range R si x P y implica y rdf:type R.
Observatie: Proprietatile sunt definite in exteriorul claselor.

Definirea proprietatilor in RDFS
(cont.)
Exemplu: Definim proprietatea detine:
detine rdfs:domain Persoana
detine rdfs:range MasinaDeCalculElectronica
Specificatia RDF:
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Persoana"/>
<rdfs:Class rdf:about="http://math.univ-ovidius.ro/Laptop">
</rdfs:Class>
<rdf:Description rdf:about="http://math.univ-ovidius.ro/detine">
<rdfs:domain>Persoana</rdfs:domain>
<rdfs:range>MasinaDeCalculElectronica</rdfs:range>
</rdf:Description>
</rdf:RDF>
Exercitiu. Sa scriem un program Java care genereaza specificatia
anterioara.
Definirea subproprietatilor in RDFS
Definitie: Pentru doua proprietati P si R definite, putem afirma ca:
P rdfs:subPropertyOf R
Observatie: Subproprietatile mostenesc restrictiile de domeniu ale
proprietatile pe care le subclasifica.
Semantica: Daca A P B atunci A R B
Exemplu:
<rdfs:Class rdf:about="http://www.univ- <rdf:Description
ovidius.ro/Persoana"/> rdf:about="http://www.univ-
ovidius.ro/areFratePe">
<rdf:Description <rdfs:range>Persoana</rdfs:range>
rdf:about="http://www.univ- <rdfs:subPropertyOf>areRudaPe
ovidius.ro/areRudaPe"> </rdfs:subPropertyOf>
<rdfs:range>Persoana</rdfs:range> </rdf:Description>
</rdf:Description>
Exercitiu. Sa scriem un program Java care genereaza specificatia

anterioara.
Definirea proprietatilor Datatype
<rdf:Description
rdf:about="http://www.univ-ovidius.ro/denumire">
<rdfs:range>
http://www.w3.org/2001/XMLSchema/string
</rdfs:range>
<rdfs:domain>Medicament</rdfs:domain>
</rdf:Description>
<rdfs:Datatype rdf:about="http://www.univ-ovidius.ro/compozitie">
<rdfs:label>compozitie</rdfs:label>
<rdfs:range>http://www.w3.org/2001/XMLSchema/string</rdfs:range>
</rdfs:Datatype>
<rdf:Description rdf:about="http://www.univ-ovidius.ro/anFabricatie">
<rdfs:range>http://www.w3.org/2001/XMLSchema/integer</rdfs:range>
</rdf:Description>
Exercitiu
Interogari SPARQL
Sa scriem un program Java care afiseaza raspunsurile la
urmatoarele intrebari:
1. Ce clase are specificatia animale.rdf? Sa fie afisate in

ordine alfabetica.
2. Ce proprietati sunt definite in specificatia animale.rdf?
3. Ce animale traiesc in apa?
4. Ce animale au blana?
5. Ce proprietati de tip Datatype au animalele?


Curs 5
2021
CUPRINS
 Specificatia RDFa
 Parsarea documentelor HTML+RDFa
 Ontologii
 Limbajul OWL. Definirea claselor in OWL

Specificatia RDFa
RDFa (acronim pentru RDF in atribute) este o specificatie
standardizata de W3C pentru introducerea constructiilor RDF
in pagini Web cu ajutorul atributelor HTML.
La fel ca si microdatele, RDFa nu are efect asupra modului in

care browser-ul arata o pagina Web.
La ora actuala, Google, Yahoo!, Bing, Facebook si o serie de

site-uri precum: Tesco, BestBuy, Overstock.com, Newsweek,
MSNBC, O’Reilly Catalog, Slideshare folosesc RDFa pentru
adnotarea semantica a paginilor web.
Rich snipped de la Google folosesc metadate pentru a

imbunatati pagina de rezultate obtinuta dupa cautare.
Concepte ale specificatiei RDFa
Atribut Semnificatie
vocab Specifica URL-ul vocabularului folosit in descrierea făcută
typeof Specifica conceptul de care apartine instanta descrisa
resource Specifica id-ul instantei (resursei) descrise
prefix Specifica prefixul si URL-ul unuia sau mai multor vocabulare
diferite de cel indicat prin vocab
src Seteaza URL-ul obiectului unei afirmatii
href Seteaza link-ul obiectului afirmatiei
property Specifica o relatie in care subiectul este valoarea atributului about
si obiectul este valoarea atributului content
rel Specifica o relatie in care subiectul este valoarea atributului about
si obiectul este valoarea atributului href
rev Specifica o relatie in care subiectul este valoarea atributului href si
obiectul este valoarea atributului about
datatype Specifica tipul de date al continutului ce constituie obiectul
afirmatiei.
Exemplu
Sa adnotam pagina HTML ce contine informatii despre cartea Palatul
chelfanelii folosind atribute RDFa.
<body>
<div vocab="https://schema.org/Book">
<h1>Palatul chelfanelii</h1>
<div prefix="sc: http://schema.org/Person">
Autor: <em property="foaf:name">Pascal Bruckner</em><br>
Locul nasterii: <span property="foaf:birthPlace">Franta</span><br>
Data nasterii:
<meta property="foaf:dateOfBirth" content=“15 Decembrie 1948”> 15 Decembrie 1948
</span>
</div> <br>
<span>Gen: </span><span property="genre"> Ghid de studiu</span><br>
<span> ISBN: </span><span property="isbn">9789737078865</span><br>
<span> Numar pagini: </span>
<span property="numberOfPages">128</span><br>
Informatii despre carte gasiti la pagina:
<a href="https://ro.wikipedia.org/wiki/Palatul_chelf%C4%83nelii"> Wikipage </a>
</div> </body>
Parsarea paginilor HTML+RDFa
Any23 (Anything to triples) este un API, un serviciu web si un
instrument de executie in linia de comanda scris in Java ce realizeaza
extragerea metadatelor din pagini HTML sau documente Web in
diferite formate:
- RDF/XML, Turtle, N3
- RDFa
- Microformate
- Microdate HTML5
- Extragerea datelor din vocabulare: FOAF, Dublin Core Terms,
schema.org, etc
Any23 este realizat de Apache: https://any23.apache.org/
Ontologii
Noţiunea de ontologie a fost împrumutată din filosofie, unde
Ontologia este o ramură a metafizicii, care studiază realitatea, adică
abordează toate entităţile (lucruri, idei sau forme) şi modurile lor de
a exista în trecut, prezent sau viitor şi relaţiile dintre ele.
În informatică, definiţia ontologiei cea mai mult utilizată a fost
dată de T. Gruber: „o ontologie este o specificaţie explicită a unei
conceptualizări” [Grub93a].
Conceptualizarea este capacitatea de abstractizare a unei
clase de obiecte care sunt apoi încorporate într-o imagine sau într-un
concept, şi de asemenea, capacitatea de a sesiza proprietăţile
distinctive ale unei clase de obiecte.
Asadar, o ontologie este o specificaţie (descriere) a unei
mulţimi de concepte (şi a relaţiilor dintre ele) necesare şi
suficiente pentru a înţelege lumea sau un domeniu de interes.

Clasificarea ontologiilor
După tipul şi gradul de formalizare a ontologiei, Gangemi et
al. [GaPi+99] clasifică ontologiile în:
 taxonomii. O taxonomie este o „vedere” a unei ontologii,
în sensul cǎ arată toate conceptele din ontologie,
organizate după relaţia de subsumare. Exemple:
SNOMED, UMLS Metathesaurus şi NCI Thesaurus.
 taxonomii axiomatizate, e.g. GALEN Core Model
 biblioteci de ontologii, adică o mulţime de taxonomii
axiomatizate cu relaţii între ele, e.g. Ontolingua
[Grub93b], în care fiecare element al bibliotecii este un
modul, care poate fi inclus într-un alt modul.
În funcţie de nivelul de generalitate, Guarino diferenţiază
patru feluri de ontologii [Guar98b]: de nivel înalt, de
domeniu, de activitate (task) şi de aplicaţie.

Scala si granularitate
Ontolo Meta-proprietǎţi
gie de Abordare Universul de Instrument Perspe Scala Granularitate
nivel discuţie formal ctivǎ
înalt
BFO Realism Universali Mereologie 3D Geografic Intenţionalǎ
Particulari (SNAP)
4D
(SPAN)
SUMO Inginereascǎ Particulari Mereologie 3D Mezoscopic Intenţionalǎ
Mereotopolo
gie
DOLCE Cognitivism Particulari Mereologie 3D+T Mezoscopic Epistemicǎ
CYC Realism Particulari Teoria 3D Microscopic Actualitate
Cognitivism mulţimilor Mezoscopic Epistemicǎ
Mereologie
GFO Realism Universali Teoria 3D+T Mezoscopic Actualitate
Cognitivism Particulari mulţimilor Epistemicǎ

Limbajul OWL (Web Ontology Language)
Limbaj de descriere a
ontologiilor standardizat de W3C.
A fost creat pentru folosirea
lui in aplicatii ce proceseaza
continutul informatiei cu scopul
de a creste gradul de interpretare
a continutului Web.
La fel ca RDFS, OWL
furnizeaza un vocabular bazat pe
XML pentru definirea claselor, a
proprietatilor lor si a relatiilor
dintre ele.

Definirea claselor in OWL
O clasa in OWL este definita ca o multime ce contine indivizi
(instante). Ele sunt descrise folosind reguli formale
(matematice) ce stabilesc precis cerintele de apartenenta a
unei instante la o clasa.
Moduri de a defini o clasa in OWL:
1. owl:Class
2. owl:unionOf (?C owl:unionOf(?A,?B))
3. owl: intersectionOf (?C owl:intersectionOf(?A,?B))
4. owl:complementOf
5. o enumerare a indivizilor ce reprezinta instante ale unei
clase din cele enumerate
6. folosind anumite restrictii de valoare sau de cardinalitate

Exemple
1. owl:Class
<owl:Class rdf:about="http://www.univ-ovidius.ro/Animal"/>
<owl:Class rdf:ID=“Caine”/>
2. owl:unionOf
<owl:Class rdf:about="http://www.univ-ovidius.ro/ObiectStelar">
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="http://www.univ-ovidius.ro/Stea"/>
<owl:Class rdf:about="http://www.univ-ovidius.ro/Asteroid"/>
</owl:unionOf>
</owl:Class>

Exemple (cont.)
3. owl: intersectionOf
<owl:Class rdf:about="http://www.univ-ovidius.ro/ApartamentDeLux">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="http://www.univ-ovidius.ro/ApartamentLocatieBuna"/>
<owl:Class rdf:about="http://www.univ-ovidius.ro/ApartamentSuprafataMare"/>
<owl:Class
rdf:about="http://www.univ-ovidius.ro/ApartamentCuVedereFrumoasa"/>
</owl:intersectionOf>
4. owl:complementOf
<owl:Class rdf:about="http://www.univ-ovidius.ro/AlimentNecomestibil"/>
<owl:Class rdf:about="http://www.univ-ovidius.ro/AlimentComestibil">
<owl:complementOf
rdf:resource="http://www.univ-ovidius.ro/AlimentNecomestibil"/>
</owl:Class>

Curs 6
2021
CUPRINS
 Limbajul OWL. Definirea claselor in OWL
 Construirea taxonomiilor a claselor OWL
 Limbajul OWL. Definirea proprietatilor
 Tipuri de proprietati obiectuale
 Restrictii asupra proprietatilor
 Ontologia DOLCE

Exemple (cont.)
5. owl: oneOf
<owl:Class rdf:about="http://www.univ-ovidius.ro/Anotimp">
<owl:oneOf rdf:parseType="Collection">
<base:Thing rdf:about="http://www.univ-ovidius.ro/Primavara"/>
<base:Thing rdf:about="http://www.univ-ovidius.ro/Vara"/>
<base:Thing rdf:about="http://www.univ-ovidius.ro/Toamna"/>
<base:Thing rdf:about="http://www.univ-ovidius.ro/Iarna"/>
</owl:oneOf>
</owl:Class>

Generarea specificatiilor OWL in Jena
public OntClass creeazaClasa(String nume){
OntClass c=model.createClass(base + nume);
return c;
}
public OntClass creeazaClasaReuniune(String nume, String[] nc){

RDFNode[] noduri = new RDFNode[nc.length];
for(int i=0; i<nc.length;i++)
noduri[i]=model.createClass(base+nc[i]);
RDFList lista = model.createList(noduri);
OntClass c=model.createUnionClass(base+nume, lista);
return c;
}

Generarea specificatiilor OWL in Jena (cont.)
public OntClass creeazaClasaIntersectie(String nume, String[] nc){
RDFNode[] noduri = new RDFNode[nc.length];
for(int i=0; i<nc.length;i++)
noduri[i]=model.createClass(base+nc[i]);
RDFList lista = model.createList(noduri);
OntClass c=model.createIntersectionClass(base+nume, lista);
return c;
}
public OntClass creeazaClasaComplementara(String nume, OntClass ac){

OntClass c=model.createComplementClass(base + nume, ac);
return c;
}

Generarea specificatiilor OWL in Jena (cont.)
public OntClass creeazaClasaInstante(String nume, String[] ni){
Resource[] instante=new Resource[ni.length];
OntClass thing=creeazaClasa("Thing");
for(int i=0;i<ni.length; i++)
instante[i]=model.createIndividual(base+ni[i], thing);
RDFList lista = model.createList(instante);
OntClass c=model.createEnumeratedClass(base+nume,lista);
return c;
}

Construirea taxonomiilor in OWL
A subsumeaza B daca si numai daca orice instanta a lui B este si
instanta a lui A.
In OWL:
<owl:Class rdf:about="http://www.univ-ovidius.ro/Calculator">
<rdfs:subClassOf>Obiect</rdfs:subClassOf>
</owl:Class>
In Java:
public void esteSubsumata(OntClass clasaCurenta, OntClass altaClasa){

clasaCurenta.addProperty(RDFS.subClassOf, altaClasa.getLocalName());
}

Definirea proprietatilor in OWL
O proprietate este o relatie binara intre doua resurse, in
care prima resursa este o clasa.
Exista doua tipuri de proprietati:
 Proprietati obiectuale – relatii intre instantele a doua
clase.
<owl:ObjectProperty>
<rdfs:domain> clasa A
<rdfs:range> clasa B
</owl:ObjectProperty>
 Proprietati datatype – relatii intre instantele unei clase si
literale RDF sau tipuri de date definite in XML Schema

Definirea proprietatilor obiectuale in OWL
<owl:ObjectProperty rdf:about="http://www.univ-ovidius.ro/sosesteIn">
<rdfs:label>sosesteIn</rdfs:label>
<rdfs:range>http://www.univ-ovidius.ro/Statie</rdfs:range>
<rdfs:domain>http://www.univ-ovidius.ro/Tren</rdfs:domain>

Tipuri de proprietati obiectuale
Proprietati simetrice
Def: O proprietate P este simetrica daca pentru orice x si
y a.i. P(x,y) daca si numai daca P(y,x).
<owl:SymmetricProperty
rdf:about="http://www.univ-ovidius.ro/esteCasatoritaCu">
<rdfs:label>esteCasatoritaCu</rdfs:label>
<rdfs:range>http://www.univ-ovidius.ro/Persoana</rdfs:range>
<rdfs:domain>http://www.univ-ovidius.ro/Persoana</rdfs:domain>
</owl:SymmetricProperty>
sau owl:ObjectProperty si
rdf:type
rdf:resource=“http://www.w3.org/2002/01/owl#SymmetricProperty”

Tipuri de proprietati obiectuale (cont.)
Proprietati tranzitive
Def: O proprietate obiectuala P este tranzitiva daca
pentru orice x, y si z: P(x,y) si P(y,z) implica P(x,z).
<owl:TransitiveProperty
rdf:about="http://www.univ-
ovidius.ro/esteStramosAlLui">
<rdfs:label>esteStramosAlLui</rdfs:label>
<rdfs:range>http://www.univ-ovidius.ro/Persoana</rdfs:range>
<rdfs:domain>http://www.univ-
ovidius.ro/Persoana</rdfs:domain>
</owl:TransitiveProperty>

Tipuri de proprietati obiectuale (cont.)
Proprietati functionale
P este functionala daca pt orice x,y si z: P(x,y) si P(x,z) implica y=z;
Range-ul in acest caz poate fi o resursa sau Datatype (String, literal)
Proprietati functionale inverse
Def: O proprietate obiectuala P este functionala inversa
daca pentru orice x, y si z: P(y,x) si P(z,x) implica y=z.
<owl:InverseFunctionalProperty
rdf:about="http://www.univ-ovidius.ro/CNP">
<rdfs:label>CNP</rdfs:label>
<rdfs:range>
http://wwww.w3.org/2001/XMLSchema/string
</rdfs:range>
<rdfs:domain>
http://www.univ-ovidius.ro/Persoana
Proprietati Datatype
In OWL:
<owl:DatatypeProperty rdf:about="http://www.univ-ovidius.ro/varsta">
<rdfs:label>varsta</rdfs:label>
<rdfs:range>http://www.w3.org/2001/XMLSchema/integer</rdfs:range>
</owl:DatatypeProperty>
In Java:
public OntProperty definesteProprietateDatatype(String nume, Resource domain,
String tip){
OntProperty p=model.createDatatypeProperty(base+nume);
p.addProperty(RDFS.domain, domain.getLocalName());
switch(tip){
case "String":
p.addProperty(RDFS.range, "http://www.w3.org/2001/XMLSchema/string");
break;
case "int":
p.addProperty(RDFS.range, "http://www.w3.org/2001/XMLSchema/integer");
break;
}
p.addProperty(RDFS.label, nume);
return p; }  Conf. univ. dr. Crenguta Puchianu
Restrictii asupra proprietatilor
Restrictiile sunt folosite pentru definirea unei proprietati
locale, adica, putem descrie faptul ca o proprietate mostenita de la o
supraclasa are codomeniul o submultime a codomeniului proprietatii
mostenite. Acest lucru inseamna ca subclasa trebuie sa restrictioneze
codomeniul unei proprietati mostenite.
O restrictie are doua parti. Prima parte indica proprietatea
asupra careia se aplica restrictia si este specificata prin
owl:onProperty. A doua parte descrie constrangerea.
In OWL sunt permise doua restrictii: de valoare si de
cardinalitate.
Pentru cele din prima categorie folosim una din formele
allValuesFrom, someValuesFrom sau hasValue.

Restrictia allValuesFrom
Pentru orice instanta a clasei ce are instante ale proprietatii
specificate, valorile proprietatii fac parte din clasa indicata de clauza
owl:allValuesFrom.
Exemplu: Pentru toate persoanele, daca ele mananca ceva, acel ceva
trebuie sa fie un aliment comestibil.
<owl:ObjectProperty rdf:about="http://www.univ-ovidius.ro/mananca">
<rdfs:label>mananca</rdfs:label>
<rdfs:range>http://www.univ-ovidius.ro/Aliment</rdfs:range>
<rdfs:domain>http://www.univ-ovidius.ro/Animal</rdfs:domain>
<owl:Restriction rdf:about="http://www.univ-ovidius.ro/Persoana">
<owl:allValuesFrom
rdf:resource="http://www.univ-ovidius.ro/AlimentComestibil"/>
<owl:onProperty rdf:resource="http://www.univ-ovidius.ro/mananca"/>
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
</owl:Restriction>

Restrictia someValuesFrom
Exista instante a clasei ce are instante ale proprietatii specificate,
pentru care valorile proprietatii fac parte din clasa indicata de clauza
owl:someValuesFrom.
Exemplu: Pentru toate persoanele, exista cel putin un aliment
comestibil mancat de persoane => ele pot manca alimente
necomestibile.
<owl:someValuesFrom
rdf:resource="http://www.univ-ovidius.ro/AlimentComestibil"/>
<owl:onProperty rdf:resource="http://www.univ-ovidius.ro/mananca"/>
</owl:Restriction>

Restrictii de cardinalitate
<owl:cardinality> este folosit pentru a specifica numarul exact de
instante dintr-o relatie.
Exemplu: Daca o persoana este casatorita, este casatorita cu exact o
alta persoana.
<owl:cardinality
rdf:datatype=http://www.w3.org/2001/XMLSchema#int>
1
</owl:cardinality>
<owl:onProperty
rdf:resource="http://www.univ-ovidius.ro/esteCasatoritaCu"/>
</owl:Restriction>

Restrictii de cardinalitate (cont.)
<owl:minCardinality> si <owl:maxCardinality> sunt folosite pentru a
specifica numarul minim si numarul maxim de instante dintr-o
relatie.
Exemplu: O persoana majora este o persoana cu varsta peste 18 ani.
<owl:minCardinality
rdf:datatype="http://www.w3.org/2001/XMLSchema#int">
18
</owl:minCardinality>
<owl:onProperty rdf:resource="http://www.univ-ovidius.ro/varsta"/>
</owl:Restriction>


Curs 7
2021
CUPRINS
 Ontologia DOLCE

Ontologia DOLCE
DOLCE este o ontologie formală care foloseşte concepte din
lingvistică, filosofie şi logică matematică, pentru a furniza o
semantică clară a limbajului natural, motivaţii ale diferenţierilor
adoptate şi reguli stricte de specificare a termenilor şi a
relaţiilor.
Categorii de nivel inalt:
- enduranti: particulari în spaţiu, care participă cel puţin într-
un perdurant (exemple de enduranti: substanţe, obiecte,
entităţi sociale).
- Perduranti: particulari în timp, care au cel puţin un
participant (e.g. evenimente, stări, procese, fenomene).

Taxonomia endurantilor ontologiei DOLCE
Endurant:
- Endurant fizic (PED)
- Obiect fizic activ (APO)
- Obiect fizic rational (RPO)
- Cantitate de materie (AOM)
- Aspect (F)
- Loc dependent (DP)
- Parte relevanta (RP)
- Obiect fizic inactiv (NAPO)
- Endurant nefizic (NPED)
- Obiect nefizic (NPOB)
- Obiect social (SO)
- Suma arbitrara (AS)
Exemple de enduranti
Categorie de endurant Exemple
Obiect fizic inactiv Calculator, Masa, Mouse, Cana, Pahar,
Pix, Stilou, Carte, Caiet, Borcan
Obiect fizic activ Pisica, Caine, Cal, Pasare
Obiect fizic rational Persoana, Femeie, Barbat
Cantitate de materie Nisip, Lichid, Metal, Lemn
Loc dependent Umbra, Orificiu
Parte relevanta Disc, Cioc, Margine masa, Alunita
Obiect nefizic Firma, Timp
Obiect social activ Parlamentul Roman
Obiect social inactiv Lege, Valuta, Economie
Obiecte mentale Dorinta, Intentie, Grija, Nevoie
Taxonomia perdurantilor, calitatilor si
abstractilor ontologiei DOLCE
Perdurant: Abstract:
- Eveniment - Propozitie
- Realizare (ACH) - Multime
- Indeplinire (ACC) - Regiune:
- Ipostaza - Regiune temporala (TR)
- Stare (ST) - Interval timp (T)
- Proces (PRO) - Regiune fizica (PR)
Calitate: - Regiune spatiala (S)
- Calitate temporala (TQ) - Regiune abstracta (AR)
- Locatie temporala (TL)
- Calitate fizica (PQ)
- Locatie spatiala (SL)
- Calitate abstracta (AQ)

Exemple de perduranti si calitati
Categorie de endurant Exemple
Proces Alergare, Ardere, Amestecare, Fierbere,
Coacere, Prajire
Stare Sta, starea de a fi multumit
Eveniment Transfer bancar, Primire mesaj
Indeplinire Conferinta, Drumetie, Performanta
Realizare Plecarea la o conferinta, Intoarcerea de
la o conferinta
Regiune fizica Teren
Calitate fizica Culoare, Forma
Calitate temporala Data de incepere a raspandirii virusului
Regiune temporala 5.05.2020, 20 minute
Calitate abstracta Gust, Miros
Relatii are_parte (hasPart) din DOLCE
• P(x,y) este relatie de ordine, pentru ca indeplineste
urmatoarele conditii:
• P(x,x)
• P(x,y)  P(y,x) -> x=y
• P(x,y)  P(y,z) -> P(x,z)
Exemplu: Viata unui om este un proces format din urmatoarele

procese: Nastere, Copilarie, Tinerete, Maturitate, Batranete,
Moarte
Subproprietati ale relatiei are_parte
• parte_proprie: PP(x,y)df =P(x,y) (x=y)
Principiul sumei:
PP(w,z) <-> (PP(w,x)  P(w,y))
• parte_directa: DP(x, y)=dfPP(x,y) ( z(PP(z,x)

P(z,y))

Descrierea mereologica a unui endurant

Descrierea mereologica (cont.)
DexOnline: Pix = Creion (sau instrument de scris) cu mina sau

cu o pasta (de tip cerneala sau gel) și cu bilă în vârf acționat de
un dispozitiv mecanic.
Componentele unui pix:

- Mina are o bila in varf si un rezervor ce contine pasta
- Varf
- Carcasa formata din: carcasa inferioara, inel si carcasa
superioara
- Clips
- Dispozitiv mecanic format din: Arc, Piesa plastic, Capac

Descrierea mereologica (cont)
Identificarea claselor:
Pix Carcasa inferioara
Creion Inel
Instrument de scris Carcasa superioara
Mina Clips
Pasta Dispozitiv mecanic
Bilă Arc
Rezervor Piesa plastic
Varf Capac
Carcasa  Conf. univ. dr. Crenguta Puchianu
Parti proprii Parti directe
x, Pix(?x) x, Pix(?x)
PP (?x,?y), Mina(?y) DP (?x,?y), Mina(?y)

PP (?x,?y), Varf(?y) DP (?x,?y), Varf(?y)
PP (?x,?y), Carcasa(?y) DP (?x,?y), Carcasa(?y)
PP (?x,?y), CarcasaInferioara(?y) DP (?x,?y), Inel(?y)
PP (?x,?y), Inel(?y) DP (?x,?y), DispozitivMecanic(?y)
PP (?x,?y), CarcasaSuperioara(?y)
PP (?x,?y), Clips(?y)
PP (?x,?y), DispozitivMecanic(?y)
PP (?x,?y), Arc(?y)
PP (?x,?y), PiesaPlastic(?y)
PP (?x,?y), Capac(?y)

Parti directe Parti directe
x, Mina(?x) x, Carcasa(?x)
DP (?x,?y), Pasta(?y) DP (?x,?y), CarcasaInferioara(?y)

DP (?x,?y), Bila(?y) DP (?x,?y), Inel(?y)
DP (?x,?y), Rezervor(?y) DP (?x,?y), CarcasaSuperioara(?y)
x, DispozitivMecanic(?x)
DP (?x,?y), Arc(?y)
DP (?x,?y), PiesaPlastic(?y)
DP (?x,?y), Capac(?y)

Relatii ontologice formale ale lui DOLCE
• esteConstituit (dolce:hasConstituent): K(x,y,t) unde x este
o entitate (perdurant sau endurant) constituită dintr-o altă
entitate y pe o anumită perioadă de timp
• Exemplu: ?p Plastic(?p), ?m Metal(?m), ?c Cerneala (?c),
?g Gel(?g)
?x, CarcasaInferioara(?x), K(?x,?p, t)
?x, CarcasaSuperioara(?x), K(?x,?p, t)
?x, Varf(?x), K(?x,?m, t)
?x, Inel(?x), K(?x,?m, t)
?x, Pasta(?x), K(?x,?c,t)
?x, Pasta(?x), K(?x,?g,t)

• Participa (dolce: isParticipantIn): un endurant participǎ într-o
apariţie (perdurant) pe durata unui interval de timp.
• Invers, intr-o aparitie exista un endurant care participa intr-un
interval de timp (dolce:hasParticipant)
Perdurant Endurant ca participant
Viata Om, Animal, Mamifer
Avalansa Zapada
Coacere Aluat
Ardere Ulei
Fierbinte Apa
Fotosinteza Clorofila, Bioxid, Apa
Fierbere Apa
• AreCalitate (dolce: hasQuality) („x are calitatea y”) are loc
între o calitate şi particularul de care aparţine: o altǎ
calitate, un endurant sau un perdurant.
Endurant Calitate fizica
Camasa Culoare
Caiet Forma
Perdurant Calitate temporala

Razboi Data de incepere
Cald Temperatura
Enduranti Calitate abstracta

nefizici
Teoria conspiratiei Manipulatoare, Neadevarate
Firma Denumire  Conf. univ. dr. Crenguta Puchianu
• AreValoare (dolce: hasRegion) („x are valoarea y”) are loc
între o calitate şi regiune.
Calitate Valoare
Culoare Rosu
Forma FormaCilindrica
Temperatura 22 grade
Denumire firma Emag
Data incepere a celui de-al doilea razboi 31 august 1939
mondial
Greutate 2kg
Latime 2cm
Lungime 3m

Relatii ontologice formale ale lui DOLCE (cont.)
Dependente:
• Depinde constant specific: SD(x,y) - în orice moment de timp t, x
nu poate fi prezent la t dacă y nu este de asemenea prezent în t.
Particular dependent Particular
Om Creier
Clips Metal
Ploaie Picatura
Ninsoare Fulgi de zapada
Coacere aluat Aluat
Fila caiet Hartie
Spirt Alcool etilic
Lapte Lactoza
Unt Grasime
Relatii ontologice formale ale lui DOLCE (cont.)
• Depinde constant specific şi unilateral: OSD(x,y) dacă şi numai
dacă x este dependent constant şi specific de y şi y nu depinde
constant de x.
Particular dependent Particular
Clips Metal
Ploaie Picatura
Coacere aluat Aluat
Caiet Hartie
Spirt Alcool etilic
Grasime porc Porc
Ceasca Ceramica
Calculator Harddisk
Fereastra Geam
Prosop de baie Tesatura  Conf. univ. dr. Crenguta Puchianu
Master: Medii virtuale multimodale distribuite

Curs 8
2021
CUPRINS
 Ontologia D&S
 Ontologia protocoalelor clinice

Ontologia D&S (Descrieri si situatii)
Dupǎ cum este cunoscut, un context sau o parte nestructuratǎ a lumii
care are loc în timp poate fi structuratǎ cu ajutorul unei interpretǎri,
intenţionale sau nu. O astfel de structurǎ poartǎ numele în D&S de
stare de fapt (en: state of affairs).
Exemple: O multime de date clinice, o multime de temperaturi cu
coordonate spatio-temporale
În D&S, conceptul de descriere este definitǎ ca fiind un obiect social
neactiv ce reprezintǎ o interpretare a unei stǎri de fapt într-un
context nefizic; din acest motiv, orice descriere este dependentǎ
constant şi generic de un agent şi este comunicabilǎ.
Un agent este definit în D&S ca un obiect fizic sau social activ capabil
sǎ conceapǎ descrieri.
Exemple: Diagnostic, Teoria conspiratiei, Teoria de modificare a
climei, Protocol clinic

În D&S o stare de fapt ce satisface o descriere este o situaţie.
O situaţie este un obiect social neactiv ce reprezintǎ o stare de fapt,

o relaţie, tuplu, sau un fapt, cu presupunerea cǎ componentele sale
„partajeazǎ” o vedere (o aranjare-setting) a domeniului unei
ontologii în virtutea unei descrieri.
Exemple: Conditie clinica, istoria modificarilor climei
Orice situatie este descrisa printr-o descriere. Relatia satisface are

loc intre situatii si descrieri si implica faptul ca cel putin un concept
al unei descrieri trebuie sa clasifice cel putin un particular din
situatia descrierii.

requisite-for
Description
modality-target requisite-for
Role Course Parameter
played-by sequenced-by valued-by
participant location-of
Situation Object Perdurant Region
location-of

Concepte in D&S. Roluri
În ontologia D&S, un concept este un obiect social (deci
nefizic) definit de o descriere. Odatǎ definit, un concept poate
fi folosit şi în alte descrieri. Relaţia de clasificare leagǎ
conceptele de particulari (şi posibil concepte de concepte) la
un moment de timp.
In D&S existǎ trei tipuri de concepte: rol, curs, şi
parametru, dupǎ tipurile de particulari din DOLCE pe care îi
clasificǎ: endurant, perdurant şi regiune.
hasRole(x,y,t) = Rol(y)  Clasifica(y,x,t)
Exemple: Profesor, Medic, Student, Avocat, Judecator, Martor,
Elev, Dezinfectant, Desert, Adjuvant, Ministru, Premier,
Presedinte, Actor, Sportiv, Antrenor, Suporter, Cantaret,
Vedeta, Fan, Instrumentist, Scriitor, Prieten, Psiholog, Mentor,
Tata, Mama, Fiu, Fiica, Sora, Frate, Verisor, Nepot, Fin,
Vanzator, Cumparator
Cursuri in D&S
S e c v e n tia liz e a z a ( x , y , t )  C u rs ( x )  C la s ific a ( x , y , t )

df
Exemple: conducere (masina), spalare (rufe, maini), gatire
(mancare), fardare (fata), ritual (Sf Liturghie, etc), imbracare,
incaltare, pregatire (lectie)
EventType(x) = Course(x)  sequences(x,y,t), unde Event(y)
Exemple: slujba de inmormantare, slujba de cununie, operatia de
cezariana, etc
Parametri in D&S
Un parametru este un concept ce clasificǎ cel puţin o valoare
dintr-o mulţime (mai precis, regiune). In plus, o astfel de
mulţime este o submulţime a extensiei unei categorii
existente din DOLCE.
E v a lu a tD e ( x , y , t )  P a r a m e tr u ( x )  C la s if ic a ( x , y , t )
df
Exemple: mare (temperatura), lung (gat), bun (om), mica
(inaltime), mediu (inteligenta, salariu, temperatura),
stralucitor (metal), inteligent (om), harnic (om), cinstit
(om), nota de trecere, admis (candidat), respins (candidat),
veche (haina), clasic (stil), vintage (moda)

Colectii in D&S
În D&S, colecţiile sunt obiect sociale (active sau nu) care, deşi
nu sunt definite de o descriere, sunt constituite generic şi
temporal de membrii sǎi şi depind (specific, unilateral şi
constant) de concepte, de aici indirect de descrieri.
Exemple: arta, armament, roi (de albine), musuroi (de furnici),
populatie, armata, echipa de fotbal, moda, grup de prieteni,
dantura
ObiectSocial
esteEchivalentaExtensional
1
Colectie apartenenta +membru Endurant
2..n
0..1 2..n
acopera
unifica clasifica
1..n 1
Descriere defineste Rol
1..n 1
Colectii organizate in D&S
Exemple: Echipa de
dezvoltare a unui
sistem software; baza
de date; stoc
magazin
Colectiile organizate
depind specific de o
descriere (e.g. model
de proces, schema
bazei de date,
inventar).

Exemplu
Generarea specificatiei OWL
Implementarea rolurilor
public OntClass creeazaClasa(String nume){
OntClass c=model.getOntClass(dolce+nume);
if(c==null) c=model.getOntClass(cdns+nume);
if(c==null) c=model.createClass(base+nume);
return c;
}
public void definesteSupraclasa(OntClass clasaCurenta,

OntClass supraclasa){
clasaCurenta.addProperty(RDFS.subClassOf,
supraclasa.getLocalName());
}

Ontologia agentilor in D&S
Un agent este definit în D&S ca un obiect
fizic sau social activ capabil sǎ conceapǎ
descrieri.
Agent(x)=PhysicalAgent(x)  SocialAgent(x)
Agentii fizici sunt obiecte care planifica
intentionat o actiune sau realizeaza
intentionat un proces sau un eveniment sau
trece printr-o stare.
Exemple: Persoana, Albina, Matca,
AgentSoftware, Robot
hasParticipant : Event -> Agent
Event subsumeaza Action
Exemplu: Albinele participa la construirea
unui fagure

Ontologia agentilor in D&S (cont.)
Agenti sociali = obiecte sociale capabile de a lua decizii prin
intermediul unui agent fizic.
Exemple: Firma, Corporatie, Institutie, Comunitate, Universitate
Un agent social necesita cel putin un agent fizic pentru a functiona:
actsFor: Agent -> SocialAgent
Exemplu: Juristul universitatii actioneaza intr-un proces juridic in
numele universitatii
Personificarea (Personification) este un agent social al carui statut
este rezultatul unei transformari culturale asupra unui obiect fizic sau
eveniment sau abstract sau unui alt obiect social, etc.
Exemple: Sfantul Potir, Bagheta (magician),Talisman, Dumnezeu,
Invierea lui Iisus
SocialPerson descrie tipurile de personalitate sociala ale persoanelor
(fiinte umane): Traditionalist, Idealist, Frustrat, Realist, Hedonist
Ontologia agentilor in D&S (cont.)
Colectiv = colectie de agenti
Exemple: corp profesoral (liceal, universitar), echipa de
dezvoltatori, clasa de elevi, grupa de studenti, fundatie de
caritate, organizatie terorista, formatie (de cantareti si
instrumentisti), galerie
Colectiv(x) = Comunitate(x)  Grup(x)
Comunitate = Colectiv cu interese, credinte sau stil de viata
comun
Exemple: Uniunea europeana, Comunitatea saseasca din
Transilvania, Comunitatea europeana a carbunelui si otelului,
Comunitatea maghiara, etc
Grup = colectiv de agenti care conceptualizeaza aceeasi
relatie. Exemple: grup de prieteni, clasa de elevi, grupa de
studenti, familie extinsa
Ontologia protocoalelor clinice
Boala(x)  Proces(x)p,t (Persoana(p)T(t)PC(p, x, t))
Corp(x)  ObiectFizicNeactiv(x)p(Persoana(p)GK(p,x))
ParteCorpAfectata(c)  ObiectFizicNeactiv(c)x (Corp(x)P(c,x))
Boala(x)  c(ParteCorpAfectata(c)PS(c,x))
StareBoala(s)  ST(s)
Boala(x)  s (StareBoala(s)PT(s,x))
Variabila(x) =df Descriere(x)y,t(Particular(y)T(t)Refera(x,y,t))
Refera(x,y,t)  Variabila(x)(Endurant(y)Perdurant(y)
Calitate(y)) T(t)
Refera(x,y,t)Endurant(y)  z,t(Concept(z)T(t)(Foloseste(x,z)
u(Descriere(u)PP(u,x)Foloseste(u,z))Clasifica(z,y,t)

Ontologia protocoalelor clinice (cont.)
NumeBoala(x)=df Variabila(x)y,t(Refera(x,y,t)Boala(y))
x1, x2, y,t(Boala(x1) Boala(x2) NumeBoala(y) T(t)
Refera(y,x1,t)Refera(y,x2,t)x1x2)
DenumireMedicala(x)  NumeBoala(x)
Boala(x)  !y,t (DenumireMedicala(y)Refera(y,x,t))
x(Boala(x) y1, y2(NumeBoala(y1)DenumireMedicala(y2)y1y2))
StadiuBoala(x)  Curs(x)
StadiuBoala(x)p,t(Particular(p)T(t)Clasifica(x,p,t) 
StareBoala(p))
ManifestareClinica(x)  Descriere(x)y(Boala(y)OSD(x,y))
ManifestareClinica(x)  y,z, m, t (Boala(y)Concept(z)
Foloseste(x,z)Clasifica(z,m,t)PD(m)PT(m,y))

Patogeneza(x)  Proces(x)
Produce(x,y)  Patogeneza(x)Boala(y)
Patogeneza(x)  y(Boala(y)Produce(x,y))
Patogeneza(x)  y(Indeplinire(y)PT(y,x))
ProceduraMedicala(x) Curs(x)y,t(T(t)Clasifica(x,y,t)Proces(y))
ProceduraMedicala(x)  y,z,t(Proces(y)Task(z)T(t)
Secventializeaza(x,z,t)PT(z,y,t))
Executa(x,y,t)  Persoana(x)z(CadruMedical(z)
ProceduraMedicala(y)T(t)JucatDe(z,x,t))
Executa(x,y,t)  z(Task(z)Secventializeaza(y,z,t)PC(x,z,t)
CadruMedical(x)  Rol(x)y,t(T(t)Clasifica(x,y,t)  Persoana(y))
Rezultat(x)  PT(x)
ProceduraMedicala(x)Executa(y,x,t)  t’,z(T(t’)(t’>t)
Rezultat(z)  PRE(z,t’)Executa(y,x,t’)
Test(x)  ProceduraMedicala(x)!y(RezultatTest(y)qt(y,x))
Test(x)  y,z,t (Task(y)T(t)Secventializeaza(x,y,t)
Substanta(z) PC(z,y,t))
Substanta(x)  CantitateDeMaterie(x)c,t(Corp(c)T(t)
Produce(c,x,t))
Produce(x,y,t)  Corp(x)Substanta(y)T(t)
CriteriuIncludere(x)=df Descriere(x)y(Variabila(y)PP(y,x))
y(z((EDAdmisibili(z)PDAdmisibili(z)RAdmisibila(z))PP(y,x)
v,p,t(Valoare(v)Are(y,v)PT(v)Clasifica(v,p,t)))
CriteriuIncludere(x)Concepe(y,x,t)  ComitetDeScriere(y)
CriteriuExcludere(x)=df Descriere(x)y(Variabila(y)PP(y,x))
y(z((EDInadmisibil(z)PDInadmisibil(z)RInadmisibila(z))PP(y,x)
 v,p,t(Valoare(v)Are(y,v)PT(v)Clasifica(v,p,t)))
CriteriuExcludere(x)Concepe(y,x,t)  ComitetDeScriere(y)

CriteriiSelectie(c)=df Descriere(c)i1,i2,e,t (CriteriuIncludere(i1)
CriteriuIncludere(i2)CriteriuExcludere(e)T(t)K(i1,c,t)K(i2,c,t)
K(e,c,t))
ProtocolClinic(x)  Descriere(x)y,t(Persoana(y)Concepe(y,x,t)
T(t)  z(ComitetDeScriere(z)Apartenenta(y,z,t))
ProtocolClinic(x)  y(CriteriiSelectie(y)P(x,y))
ProtocolClinic(x)  y(Obiectiv(y)P(x,y))
ProtocolClinic(x)  y(ProceduraMedicala(y)Foloseste(x,y))
ProtocolClinic(x)  y(Rol(y)Defineste(x,y))
StudiuClinic(x)  Curs(x)y,t(T(t)Clasifica(x,y,t) 
Proces(y))
StudiuClinic(x)  y(ProtocolClinic(y)Defineste(y,x))
StudiuClinic(x)  y, z,t(Proces(y)T(t)Clasifica(x,y,t)
ProceduraMedicala(z)Clasifica(z,y,t))
ProceduraTerapeuticaStudiu(x)  ProceduraTerapeutica(x)
StudiuClinic(x)  !y, z,t(Proces(y)T(t)Clasifica(x,y,t)
ProceduraTerapeuticaStudiu(z)Clasifica(z,y,t))
Participant(x)  Rol(x) y,t(T(t)Clasifica(x,y,t) 
(Persoana(y)ObiectSocialActiv(y))JucatDe(x,y,t))
Participant(x)  y, z, t, p(StudiuClinic(y)Proces(z)T(t)
Clasifica(y,z,t)  Persoana(p)JucatDe(x,p,t)PC(p,z,t)
Subiect(x)  Participant(x)y,t(T(t)Clasifica(x,y,t) 
Persoana(y)JucatDe(x,y,t))
Subiect(x)  y, z, t, p(StudiuClinic(y)Proces(z)T(t)
Clasifica(y,z,t) Persoana(p)JucatDe(x,p,t)PC(p,z,t) 
z1, p1(ProceduraTerapeuticaStudiu(z1)Clasifica(z1,z,t)
Persoana(p1)Executa(p1, z1, t)))

PopulatieStudiu(x)  ColecţieOrganizata(x)pt(T(t)
Apartenenta(p,x,t)  Persoana(p))rd (Caracterizeaza(r,c) 
Subiect(r)CriteriiSelectie(d)Acopera(r,d))
AgentTerapeutic(x) Agent(x)y,z,p,t, t1(StareClinicaGenerala(y)
T(t) Persoana(p)PC(p,y,t)EsteAdministrat(x,y,t)
StareClinicaGenerala(z) T(t1)P(t,t1)PC(p,z,t1) PC(p,y,t1))
EsteAdministrat(x,y,t)  Cauzeaza(x,y,t)AgentTerapeutic(x)
StareClinicaGenerala(y) T(t)
ProceduraTerapeutica(x)  ProceduraMedicala(x)x1,y,y1,t
(PD(x1)T(t) Clasifica(x,x1,t)AgentTerapeutic(y)(Endurant(y1)
Perdurant(y1)) Clasifica(y,y1,t)(PC(y1,x1,t)P(y1,x1))


Cursuri 12 si 13
2022
CUPRINS
 Definirea relatiilor
 Definirea constrangerilor
 Limbajul SWRL
 Reguli SWRL ale ontologiei painii
 Motoare de rationament
 Sistemul Ontop
 Verificarea consistentei unei ontologii

Definirea relatiilor
 pastreaza(x,y,t) -> PT(x)^PED(y)^
T(t)^ weak-connection(x,y,t)
 traieste(x,y,t) ->
ED(x)^Tara(y)^T(t)^place(x,y,t)
Limbajul SWRL
Semantic Web Rule Language este un limbaj de specificare a
regulilor folosind o combinaţie a limbajelor OWL DL şi OWL Lite cu
Unary/Binary Datalog RuleML, sublimbaje ale lui Rule Markup
Language.
Regulile sunt construite sub forma unor implicaţii între un
antecedent şi o consecinţă. O astfel de regulă este interpretată
astfel: când condiţiile din antecedent sunt adevărate, consecinţa
trebuie de asemenea să fie adevărată.
Atât antecedentul cât şi consecinţa pot fi formaţi din unul sau
mai mulţi atomi.
Atomii multiplii sunt formaţi din conjuncţii de atomi care pot fi
predicate unare C(x) sau binare P(x,y) sau tipuri de date, unde C
este un concept, P este o proprietate, iar x şi y pot fi fie variabile
(prefixate de ?) ce semnifică instante ale conceptelor ontologiei, fie
valori de date OWL.
Reguli SWRL (cont)
ontologiatomis:Aryballos(?a) ^ ontologiatomis:Inaltime(?i) ^ dolce-lite:has-
quality(?a, ?i) ^ ontologiatomis:Valoare(?v) ^ dolce-lite:has-quale(?i, ?v) -
> swrlb:greaterThan(?v, "15"^^xsd:int) ^ swrlb:lessThan(?v,
"20"^^xsd:int)
ontologiatomis:Capac(?c) ^ ontologiatomis:Lekanis(?l) ^ dolce-lite:space-

region(?r) -> spatialrelations:spatial-location(?c, ?r) ^
spatialrelations:spatial-location(?l, ?r)
ontologiatomis:Skyphos(?s) ^ dolce-lite:time-interval(?t) ^
ontologiatomis:Persoana(?p) ^ extendeddns:makes(?p, ?s) ->
temporalrelations:present-at(?p, ?t) ^ dolce-lite:spatio-temporally-present-
at(?p, ontologiatomis:Grecia)
ontologiatomis:Apa(?a) ^ ontologiatomis:Vin(?v) ^
ontologiatomis:Crater(?c) ^ ontologiatomis:Amestecare(?m) ^
ontologiatomis:pastreaza(?c, ?a) ^ ontologiatomis:pastreaza(?c, ?v) ->
dolce-lite:participant-in(?a, ?m) ^ dolce-lite:participant-in(?v, ?m)
Motoare de rationament
Module ce valideaza modelele ontologice prin realizarea urmatoarelor
functionalitati:
- Verificarea consistentei: clasele, proprietatile si definitiile lor
formale nu descriu fapte contradictorii. Exemple:
- o clasa are doua supraclase care sunt disjuncte.
- fie o proprietate p:A->B. Definim o constrangere prin care
specificam ca toate instantele lui C trebuie sa aiba proprietatea p,
unde C si A sunt clase disjuncte.
- Satisfacerea conceptelor: verifica apartenenta instantelor la

concepte.
- Clasificarea: verifica taxonomia ontologiei
Exemple: Pellet, FaCT++, RacerPro, HerMiT, Ontop

Sistemul Ontop
Este un sistem de Protege Sesame Optique platform
Stratul aplicatie
accesare a datelor Workbench &
SPARQL Endpoint
bazate pe ontologie.
Permite interogarea
surselor de date Stratul API
API OWL API Sesame/RDF4J
relationale printr-o
reprezentare Ontop SPARQL Query Answering Engine (Quest)
ontologica a datelor Ontop Core
API OWL (OWL API JDBC API Sesame (Parser
(furnizata de o Parser) R2RML SPARQL)
ontologie).
A fost dezvoltat de Interogari
Ontologii Mapari Baze de date
Free University din OWL 2 R2RML relationale
SPARQL
Bozen-Bolzano.
https://ontop-vkg.org//
Verificarea consistentei unei ontologii
Verificarea consistentei presupune verificarea urmatoarelor
elemente:
• Taxonomia claselor
• Taxonomia proprietatilor
• Asertiunile claselor
• Asertiunile proprietatilor obiectuale si datatype
• Aceleasi instante sa nu apara in clase diferite
Verificarea consistentei unei ontologii cu Ontop:
1. Instalare Ontop (File>Check for plugins…)
2. Setarea driver-ului jdbc (File>Preferences>tab JDBC Drives>Add
) vezi slide 9
3. Alegere Ontop 4.2 (Reasoner)
4. Conectarea la baza de date (Ontop mappings>connection
parameter) vezi slide 11
5. Pornire Ontop (Reasoner- start reasoner)
6. Verificare (submeniul Ontop > Check for inconsistencies…)
Vizualizare tab Ontop Mappings
Conectarea Ontop la baza de date
Pornirea Ontop
Verificarea consistentei ontologiei Tomis

Pas 5. Definirea relațiilor
Relatiile (proprietati sau predicate) leaga subiecte de obiecte (cf tripletelor RDF).
Fiecare proprietate are un domeniu si un range (codomeniu).
Exista doua tipuri de proprietăți:
- Obiectuale, cand domeniul si codomeniul sunt clase existente in taxonomie/ontologie

=> proprietatea are loc intre doua instante ale claselor relatiei
- Datatype, cand domeniul este o clasă, iar range-ul este un tip de date => proprietatea
are loc intre o instanta a clasei domeniului şi o valoare din tipul de date care descrie
range-ul relatiei.
Definirea proprietatilor:
- Pentru definirea unei proprietati obiectuale, se identifica mai intai proprietatea pe care
o subclasifica (din ontologia curenta sau cele importate) si se restrictionează domeniu,
respectiv range-ul proprietatii.
- Pentru proprietate datatype: submeniul Data properties -> se selecteaza
topDataProperty -> se creeaza subproprietarea estePlasata si se restrictioneaza
domeniul (la Toarta) si range-ul (la xsd:string)
Pas 6. Restrictii asupra proprietatilor

In acest pas sunt descrise conceptele/clasele prin constrȃngeri (restrictii) asupra proprietatilor
moştenite sau definite la pasul anterior.
Pe langa definirea caracteristicilor unor proprietati este posibila restrictionarea acestora in
contexte specifice in diverse moduri, folosind restrictii OWL. Aceste constrangeri sunt
realizate lui owl:Restriction. Elementul owl:onProperty indica proprietatea restrictionata.
Clasa owl:Restriction este o subclasa a lui owl:Class.
Fig. Error! No text of specified style in document.-1 Restriction Class

Proprietatile clasei owl:Restriction sunt:
 onProperty: rdf:Property
 allValuesFrom (only): rdfs:Class
1
 hasValue (exactly): xsd:nonNegativeInteger rdfs:Class
 someValuesFrom: rdfs:Class
 cardinality: xsd:nonNegativeInteger
 minCardinality: xsd:nonNegativeInteger
 maxCardinality: xsd:nonNegativeInteger
Restrictiile sunt folosite pentru definirea unei proprietati locale, adica, putem descrie faptul ca
o proprietate mostenita de la o supraclasa are codomeniul o submultime a codomeniului
proprietatii mostenite. Acest lucru inseamna ca subclasa trebuie sa restrictioneze codomeniul
unei proprietati mostenite.
O restrictie are doua parti. Prima parte indica proprietatea asupra careia se aplica restrictia si
este specificata prin owl:onProperty. A doua parte descrie constrangerea. In OWL sunt permise
doua restrictii: de valoare si de cardinalitate. Pentru cele din prima categorie folosim una din
formele allValuesFrom, someValuesFrom sau hasValue.
1.1.1.1 allValuesFrom
Restrictia owl:allValuesFrom inseamna ca pentru orice instanta a clase ce are instante
ale proprietatii specificate, valorile proprietatii fac parte din clasa indicata de clauza
owl:allValuesFrom.
<owl:Class rdf:ID=”Aliment”>
<owl:Class rdf:about=”#AlimentComestibil”>
<rdfs:subClassOf rdf:resource=”Aliment”>
<owl:Class>
<owl:ObjectProperty rdf:ID=”mananca”>
<rdfs:domain rdf:resource=”Animal”>
<rdfs:range rdf:resource=”Aliment”>
<owl:Class rdf:about="#Persoana">
<rdfs:subClassOf rdf:resource=”Animal”>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#mananca"/>
<owl:allValuesFrom rdf:resource="#AlimentComestibil"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
In acest exemplu, Persoana este o subclasa a clasei Animal si subclasa a unei clase anonime
care are proprietatea mananca si toate valorile acestei proprietati trebuie sa fie instante ale clasei
AlimentComestibil. Orice ar manca o persoana trebuie sa fie un aliment comestibil. Aceasta
restrictie se aplica numai clasei Persoana, nici unei alte subclase a clasei Animal.
1.1.1.2 owl:someValuesFrom
Restrictia owl:someValuesFrom este similara. Daca inlocuim owl:allValuesFrom
din exemplul anterior cu owl:someValuesFrom, ar insemna ca cel putin una din instantele
proprietatii mananca a clasei Persoana trebuie sa puncteze un individ care este o instanta a clase
AlimentComestibil. Altfel spus, orice persoana mananca cel putin un aliment comestibil.
2
Asadar, diferenta dintre cele doua tipuri de restrictii este acceasi cu diferenta dintre
cuantificatorii universal si existential.
Restrictie Semnificatie
Pentru toate persoanele, daca ele mananca ceva, acel ceva trebuie sa fie
allValuesFrom
un aliment comestibil.
Pentru toate persoanele, exista cel putin un aliment comestibil mancat

someValuesFrom
de persoane.
Prima restricie nu cere ca o persoana sa manance. Dar daca persoana mananca, atunci ea
mananca un aliment comestibil. A doua restrictie cere ca sa existe cel putin un aliment
comestibil mancat de persoane, dar ele pot manca si alimente necomestibile.
1.1.1.3 hasValue
Proprietatea hasValue ne permite sa descriem clase pe baza anumitor valori ale unei
proprietati. Un individ poate fi instanta a unei clase daca cel putin una din valorile proprietatii
este egala cu resursa hasValue.
Definim clasele Facultate si FacultateDeMatematicaSiInformatica, ca subclasa a primeia.
<owl:Class rdf:ID="Facultate"/>
<owl:Class rdf:ID="FacultateDeMatematicaSiInformatica">
<rdfs:subClassOf rdf:resource="#Facultate"/>
</owl:Class>
Definim clasa Departament:
<owl:Class rdf:ID="Departament"/>
Si proprietatea functionala apartineDe intre Departament si Facultate:
<owl:FunctionalProperty rdf:ID="apartineDe">
<rdf:type
rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>
<rdfs:domain rdf:resource="#Departament"/>
<rdfs:range rdf:resource="#Facultate"/>
</owl:FunctionalProperty>
Definim clasa DepartamentInformaticaSiMatematicaAplicata ca o subclasa a lui Departament
si a unei clase anonime in care se defineste restrictia ca apartine de
FacultateDeMatematicaSiInformatica.
<owl:Class
rdf:ID="DepartamentInformaticaSiMatematicaAplicata">
<rdfs:subClassOf rdf:resource="#Departament"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#apartineDe"/>
<owl:hasValue
rdf:resource="#FacultateDeMatematicaSiInformatica"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
Notam ca – similar cu allValuesFrom si someValuesFrom – aceasta restrictie este
locala. Este adevarata numai pentru proprietatea apartineDe din clasa
DepartamentInformaticaSiMatematicaAplicata.
3
1.1.1.4 Cardinalitate
Cardinalitatea se refera la numarul de aparitii.
Constrangerile de cardinalitate se impun folosind owl:cardinality si permit specificarea
numarului exact de indivizi dintr-o relatie.
<owl:Class rdf:ID="Persoana">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#esteCasatoritCu”/>
<owl:cardinality
rdf:datatype=”http://www.w3.org/2001/XMLSchema#nonNegativ
eInteger”>1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
Proprietatea esteCasatoritCu este functionala, adica orice persoana este are cel mult o sotie sau
sot. Cardinalitatea de 1 spune ca orice persoana este casatorita cu exact o alta persoana.
In OWL DL putem specifica si intervale de cardinalitati folosind owl:minCardinality
(pentru marginea inferioara) si owl:maxCardinality (pentru marginea superioara).
Exemplu: O persoana majora este o persoana cu varsta mai mare de 18 ani.
<owl:DatatypeProperty rdf:about="#varsta">
<rdfs:domain rdf:resource="#Persoana"/>
<rdfs:range
rdf:resource="http://www.w3.org/2001/XMLSchema#int"/>
</owl:DatatypeProperty>
<owl:Class rdf:ID="PersoanaMajora">
<rdfs:subClassOf rdf:resource="#Persoana"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:minCardinality
rdf:datatype="http://www.w3.org/2001/XMLSchema#int"> 18
</owl:minCardinality>
<owl:onProperty>
<owl:DatatypeProperty rdf:ID="varsta"/>
</owl:onProperty>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
Exemplu: varsta unui adolescent variaza intre 14 si 18.
<owl:Class rdf:ID="Adolescent">
<rdfs:subClassOf>
<owl:Restriction>
<owl:maxCardinality
rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
>18</owl:maxCardinality>
<owl:onProperty>
4
<owl:DatatypeProperty rdf:about="#varsta"/>
</owl:onProperty>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:minCardinality
rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
>14</owl:minCardinality>
<owl:onProperty>
<owl:DatatypeProperty rdf:about="#varsta"/>
</owl:onProperty>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf rdf:resource="#Persoana"/>
</owl:Class>

Cursuri Web Semantic Si Ontologii

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cursuri Web Semantic Si Ontologii

Încărcat de

Drepturi de autor:

Formate disponibile

Universitatea Ovidius Constanta

Facultatea de Matematica si Informatica

Web semantic si ontologii

 Web semantic. Metadate

 Conf. univ. dr. Crenguta Puchianu

 Conf. univ. dr. Crenguta Puchianu

Conceptul a fost introdus de catre Tim Berners-Lee si W3C (World

 Conf. univ. dr. Crenguta Puchianu

schema.org este un standard de metadate (vocabular), ce contine o

itemscope Specifica faptul ca secventa care urmeaza este o

itemtype Descriem o instanta a conceptului dat ca valoare a

itemprop Fiecare concept se caracterizeaza printr-o serie de

 Conf. univ. dr. Crenguta Puchianu

Informatii despre carte gasiti la pagina:

microdate pentru a descrie restaurantul “Pescaria lui Matei.

Exercitiul 2. Să se scrie un program care citeşte proprietăţile

instantei conceptului Restaurant, crează un obiect clasei

Restaurant şi afisează datele obiectului ȋn două formate: cel

definit ȋn metoda toString() şi JSON.

Web semantic si ontologii

 Arhitectura Web-ului semantic

 Scrierea si citirea documentelor RDF

 Conf. univ. dr. Crenguta Puchianu

Cuvȃnt cheie Semnificaţie

 Conf. univ. dr. Crenguta Puchianu

O secvenţă JSON-LD poate fi citită şi analizată de către programe

Pas 3. Scriem clasa AplicatieJSON

 Conf. univ. dr. Crenguta Puchianu

Un document RDF este reprezentat de un document XML

 Conf. univ. dr. Crenguta Puchianu

Corectitudinea unui document RDF poate fi verificata folosind

 Conf. univ. dr. Crenguta Puchianu

 Conf. univ. dr. Crenguta Puchianu

Jena - API implementat în Java pentru dezvoltarea

Documentatia poate fi gasita la adresa:

Pentru a folosi Jena, trebuie să importam arhivele jar ale

 Conf. univ. dr. Crenguta Puchianu

Nume element programare Java Descriere

 Conf. univ. dr. Crenguta Puchianu

2. Scrierea unui program care genereaza si afiseaza specificatia RDF

Web semantic si ontologii

 Legarea resurselor in RDF

 Folosirea mai multor vocabulare in RDF

 Definirea relatiilor in RDF

 Descrierea colectiilor de resurse RDF

 Programe Java pentru interogari SPARQL

 Conf. univ. dr. Crenguta Puchianu

Calculatorul cantareste 2 kg.

 <rdf:Bag>– descrie un container de resurse sau literale

Exemplu: Completarea descrierii revistei Taifasuri cu

 <rdf:Seq>– descrie un container de resurse sau literale

Exemplu: Scrierea unui program Java care genereaza o

Obs. Pot fi folositi modificatorii: ORDER BY, LIMIT nr

Web semantic si ontologii

 RDF Schema. Concepte de baza

 Definirea claselor in RDFS

 Definirea unei taxonomii in RDFS

 Definirea proprietatilor si a subproprietatilor

 Conf. univ. dr. Crenguta Puchianu

Exercitiu. Sa scriem un program Java care genereaza

Literal Defineste un literal rdfs:literal

Daca P rdfs:domain D si x P y implica x rdf:type D.

Daca P rdfs:range R si x P y implica y rdf:type R.