O.Curé [1 ] 3 Le web sémantique
O.Curé [2 ] Une extension du Web actuel "The Semantic Web is an extension of the current web in which information is given well-defined meaning, better enabling computers and people to work in cooperation." [1]. Comment y parvenir? À l'aide de structures XML En développant des ontologies.
O.Curé [3 ] XML n'est pas suffisant XML est comme HTML mais il permet de définir ses propres balises. Mais avec XML, on ne peut pas exprimer le sens des balises. C'est le rôle des ontologies qui : expriment la sémantique dans un formalisme interprétable par les machines. permettent à des programmes indépendants d'échanger des données / connaissances.
O.Curé [4 ] L'architecture du web sémantique
O.Curé [5 ] URI et espace de noms Le Web est un espace informationnelle Les ressources sont les points de cet espace. URI : nom ou adresse dénotant une ressource. Espace de noms Ensemble de noms utilisés comme éléments et attributs. Identifié par une URI.
RDF et RDFS O.Curé [6 ]
O.Curé [7 ] Présentation de RDF (Resource Description Framework) Un langage pour décrire des ressources Exploite les métadonnées pour décrire les ressources du Web. Propose donc une interopérabilité entre applications qui partagent des informations (interprétables par les machines) sur le Web. Possède une syntaxe XML (mais ce n'est pas l'unique syntaxe).
O.Curé [8 ] RDF, pour faire quoi? Amélioration de la découverte de ressources sur le Web. Etablir des catalogues de ressources (décrire le contenu et les relations). Développement d'agents intelligents. Spécifier la sémantique des données d'un document XML.
Modèle de données RDF Equivalent aux réseaux sémantiques [Staab 2000] : graphe orienté avec labels. Les noeuds représentent des concepts, des instances et les valeurs des propriétés. Les arcs représentent des propriétés entre concepts. [Stabb2000] : Staab, S. Erdmann, M. Maedche, A., Decker, S. : An extensible approach for modeling ontologies ins RDF(S). ECDL 2000 O.Curé [9 ]
Modèle de données RDF (2) 3 composants Resources : des données décrites en RDF. Elles sont décrites à l'aide d'expressions RDF et sont référencées par des URI. Properties (predicates) : elles définissent les attributs ou relations utilisés pour décrire les ressource. Statements : elles assignent une valeur à une propriété pour une ressource. C'est donc un triplet. [Stabb2000] : Staab, S. Erdmann, M. Maedche, A., Decker, S. : An extensible approach for modeling ontologies ins RDF(S). ECDL 2000 O.Curé [10 ]
O.Curé [11 ] RDF triplet Une déclaration RDF est un triplet constitué d'un sujet, d'une propriété et d'un objet. D'un sujet (resource) Un objet du domaine Pointé par un identifiant (URI) D'une propriété (predicat relation) Relation binaire sur le domaine entre un sujet et un objet. Également une ressource (URI). D'un objet
O.Curé [12 ] Concepts clés de RDF Modèle les déclarations sous forme d'un graphe (orienté labellisé). Exploite les URI, espace de noms Possibilité de typer les données Proposer des litéraux Plusieurs présentations (XML, N3, N- triples, graphique). Exprime des faits simples
O.Curé [13 ] Modélisation avec RDF Primitives : 7 pour les classes, 7 pour les propriétés et une pour les instances Classe : rdf:statement : la classe des triplets contenant un sujet, une propriété et un objet. rdf:property : la classe des propriétés rdf:bag, rdf:seq et rdf:alt : les classes des collections. rdf:list : la classe des listes RDF. rdf:xmlliteral : un type de donnée,qui permet de définir une classe pour les littéraux XML.
O.Curé [14 ] Modélisation avec RDF (2) Propriété : rdf:first et rdf:rest : représentent la relation entre une liste et son premier élément (le reste des éléments). rdf:predicate, rdf:subject et rdf:object : ils définissent les ressources propriété, le sujet et l'objet d'une déclaration (statement). rdf:type : pour définir la classe d'appartenance d'une ressource. rdf:value : pour définir la valeur d'une propriété lorsque celle-ci est une ressource structurée (un RDF statement). Instance rdf:nil : pour décrire une liste vide.
O.Curé [15 ] Sérialisation XML/RDF Code XML/RDF : <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdfsyntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/"> <rdf:description rdf:about="http://www.univmlv.fr/~ocure"> <dc:title>page de olivier Cure</dc:title> <dc:author>olivier Cure</dc:author> </rdf:description> </rdf:rdf>
Représentation graphique Noeud : sujet et objet arc : prédicat Génération : http://www.w3.org/rdf/validator/ O.Curé [16 ]
Formats N-triples et N3 Format N-triples <http://www.univ-mlv.fr/~ocure> <http://purl.org/dc/elements/1.1/title> "Page de olivier Cure". <http://www.univ-mlv.fr/~ocure> <http://purl.org/dc/elements/1.1/author> "Olivier Cure". Format N3 @prefix dc: <http://purl.org/dc/elements/1.1/>. @prefix rdf: <http://www.w3.org/1999/02/22-rdfsyntax-ns#>. <http://www.univ-mlv.fr/~ocure> dc:author "Olivier Cure"; dc:title "Page de olivier Cure". Génération : http://www.mindswap.org/2002/rdfconvert/ O.Curé [17 ]
O.Curé [18 ] Liaisons entre déclarations Le sujet d'une déclaration peut être l'objet d'une autre déclaration. On obtient alors de graphes orientés labellisés. <rdf:rdf xmlns:rsrc="http://www.univ-mlv.fr/~ocure/rsrc#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:description rdf:about="http://www.univmlv.fr/~ocure"> <dc:author>olivier Cure</dc:author> <dc:title>page Web de Olivier Cure</dc:title> <rsrc:univ rdf:resource="http://www.univ-mlv.fr"/> </rdf:description> <rdf:description rdf:about="http://www.univ-mlv.fr"> <rsrc:propb>valeur propb</rsrc:propb> </rdf:description> </rdf:rdf>
Liaisons entre déclarations O.Curé [19 ]
O.Curé [20 ] On pouvait aussi écrire <rdf:rdf xmlns:rsrc="http://www.univ-mlv.fr/~ocure/rsrc#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:description rdf:about="http://www.univmlv.fr/~ocure"> <dc:author>olivier Cure</dc:author> <dc:title>page Web de Olivier Cure</dc:title> <rsrc:univ> <rdf:description rdf:about="http://www.univ-mlv.fr"> <rsrc:propb>valeur propb</rsrc:propb> </rdf:description> </rsrc:univ> </rdf:description> </rdf:rdf>
O.Curé [21 ] Sérialisation XML Racine RDF et espace de nommage <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22- rdf-syntax-ns#">... </rdf:rdf>
O.Curé [22 ] Description d'éléments Les attributs About : pour se référer à une URI d'une ressource existante. Id : pour spécifier la création d'une nouvelle ressource <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdfsyntax-ns#"> <rdf:description about= http://www.univ-mlv.fr/~ocure >... </rdf:description> </rdf:rdf>
O.Curé [23 ] Propriétés et éléments Syntaxe : <propriété>valeur</propriété> Utiliser des espaces de noms pour qualifier les propriétés Les valeurs sont des éléments ou bien des chaînes de caractères. <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc= http://purl.org/dc/elements/1.1/ > <rdf:description about= http://www.univ-mlv.fr/~ocure > <dc:creator>olivier Curé</dc:creator> </rdf:description> </rdf:rdf>
O.Curé [24 ] Ressources multiples <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc= http://purl.org/dc/elements/1.1/ > <rdf:description about= http://www.univ-mlv.fr/~ocure/enseignement/ist > <dc:creator>olivier Curé</dc:creator> <dc:title>page sur l'enseignement en Master 2 IST</dc:title> <dc:date>2004-01-01</dc:date> </rdf:description> <rdf:description about= http://www.univ-mlv.fr/~ocure/enseignement/ing2000 > <dc:creator>olivier Curé</dc:creator> <dc:title>page sur l'enseignement Ingenieurs 2000</dc:title> <dc:date>2004-01-02</dc:date> </rdf:description> </rdf:rdf>
O.Curé [25 ] Imbrication de ressources <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns #" xmlns:dc= http://purl.org/dc/elements/1.1/ xmlns:vcard= http://imc.org/vcard/3.0# > <rdf:description about= http://www.univ-mlv.fr/~ocure /enseignement/ist > <dc:creator> <vcard:fn>olivier Curé</vcard:FN> <vcard:email>ocure@univ-mlv.fr</vcard:email> </dc:creator> </rdf:description> </rdf:rdf>
O.Curé [26 ] Références entre ressources <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc= http://purl.org/dc/elements/1.1/ xmlns:vcard= http://imc.org/vcard/3.0# > <rdf:description about= http://www.univ-mlv.fr/~ocure /enseignement/ist > <dc:creator rdf:resource= http://www.univ-mlv.fr/~ocure /> </rdf:description> <rdf:description about= http://www.univ-mlv.fr/~ocure > <vcard:fn>olivier Curé</vcard:FN> <vcard:email>ocure@univ-mlv.fr</vcard:email> </rdf:description> </rdf:rdf> Faire référence à un objet décrit dans le document.
Blank nodes "A blank node is a node that is not a URI reference or a literal... A blank node is just a unique node that can be used in one or more RDF statements" (*). Equivalent à des variables quantifiées existentiellement. 2 avantages: Relations n-ary (n>2). Ecrire des descriptions sur des ressources pouvant ne pas avoir d'uris mais ayant des relations avec des ressources ayant des URIs. * : Resource Description Framework : Concepts and abstract syntax (W3C) O.Curé [27 ]
O.Curé [28 ] Blank nodes (2) En RDF/XML, on fait référence à un noeud vide à l'aide de l'attribut: rdf:nodeid
O.Curé [29 ] Blank node exemple <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdfsyntax-ns#" xmlns:exterms="http://www.example.org/terms/"> <rdf:description rdf:about="http://www.univmlv.fr/~ocure"> <exterms:pred1 rdf:nodeid="x1"/> </rdf:description> <rdf:description rdf:about="http://www.univmlv.fr/~truc"> <exterms:pred1 rdf:nodeid="x1"/> </rdf:description> <rdf:description rdf:nodeid="x1"> <exterms:pred3>val3</exterms:pred3> <exterms:pred4>val4</exterms:pred4> </rdf:description> </rdf:rdf>
Comme un graphe O.Curé [30 ]
O.Curé [31 ] Conteneurs RDF 3 types : rdf:bag : une liste non ordonnée avec duplicats. rdf:seq : liste ordonnée avec duplicats rdf:alt : une liste d'alternatives (choix) Avec ces collections RDF, il est possible de décrire des groupes contenant des membres sélectionnes.
O.Curé [32 ] rdf:bag exemple <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc= http://purl.org/dc/elements/1.1/ > <rdf:description about= urn:isbn:0-666-12345-7 > <dc:creator> <rdf:bag> <rdf:li>pierre</rdf:li> <rdf:li>paul</rdf:li> <rdf:li>jean</rdf:li> </rdf:bag> </dc:creator> </rdf:description> </rdf:rdf>
Réification* Lorsqu'une déclaration est modelée comme la ressource d'une autre déclaration. Exemple : Gabriella déclare que Olivier est le créateur de la page Web http://www.univ-mlv.fr/~ocure. Exprime la provenance (information sur la source d'une description), la ressemblance, le contexte ou des relations temporelles. Dans WordNet : regarding something abstract as a material thing O.Curé [33 ]
O.Curé [34 ] Réification le code <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntaxns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:s="http://www.schemas.org/schema/"> <rdf:description> <rdf:subject rdf:resource="http://www.univmlv.fr/~ocure"/> <rdf:predicate rdf:resource="http://purl.org/dc/elements/1.1/creator"/> <rdf:object>olivier</rdf:object> <rdf:type rdf:resource="http://www.w3.org/1999/02/22- rdf-syntax-ns#statement"/> <s:attributedto>gabriella</s:attributedto> </rdf:description> </rdf:rdf>
Réification le graphe O.Curé [35 ]
O.Curé [36 ] Syntaxe abrégée On peut convertir les propriétés en attributs <rdf:description about= http://www.univ-mlv.fr/~ocure /enseignement/ist > <dc:creator>olivier Curé</dc:creator> <dc:title>page sur l'enseignement en Master 2 IST</dc:title> <dc:date>2004-01-01</dc:date> </rdf:description> devient <rdf:description about= http://www.univ-mlv.fr/~ocure /enseignement/ist dc:creator= Olivier Curé dc:title= Page sur l'enseignement en Master 2 IST dc:date= 2004-01-01 />
O.Curé [37 ] Syntaxe abrégée (2) La description d'un élément imbriqué peut être réécrit à l'aide d'attributs <rdf:description about= http://www.univ-mlv.fr/~ocure /enseignement/ist > <dc:creator> <rdf:description about= http://www.univ-mlv.fr/~ocure > <vcard:fn>olivier Curé</vcard:FN> <vcard:email>ocure@univ-mlv.fr</vcard:email> </rdf:description> </dc:creator> </rdf:description> devient <rdf:description about= http://www.univ-mlv.fr/~ocure /enseignement/ist > <dc:creator rdf:resource= http://www.univ-mlv.fr/~ocure vcard:fn= Olivier Curé vcard:email= ocure@univ-mlv.fr /> </rdf:description>
O.Curé [38 ] Syntaxe abrégée (3) La valeur d'un rdf:type devient un élément <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/"> <rdf:description about="http://www.univ-mlv.fr/~ocure/"> <rdf:type rdf:resource="http://www.schemas.org/www/webpage"/> <dc:creator>olivier Curé</dc:creator> <dc:title>programmation Java XML</dc:title> <dc:date>2004-01-01</dc:date> </rdf:description> </rdf:rdf> Devient <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:s="http://www.schemas.org/www/"> <s:webpage about="http://www.univ-mlv.fr/~ocure/" dc:creator= Olivier Curé dc:title= Programmation Java XML dc:date= 2004-01-01 /> </rdf:rdf>
O.Curé [39 ] Outils RDF Parser/serializer Converter/Scraper Microformat: permet de structurer l'information d'une page web à l'aide de vocabulaire (calendrier, geo,etc.). GRDDL (Gleaning Resource Descriptions from Dialects of Languages): supporte le mapping de microformats vers RDF. RDFa utilise les tags HTML pour intégrer de l'information pouvant être 'parsée' en RDF. RDF store (stokage, requête, fusion de données)
O.Curé [40 ] Du RDF dans du HTML <html> <head> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntaxns#" xmlns:dc="http://purl.org/dc/elements/1.1/"> <rdf:description about="" dc:creator="olivier Curé" dc:title="programmation Java et XML" dc:date="2004-10-10"/> </rdf:rdf> <title>programmation Java et XML pour les M2 IST</title> </head> <body>... </body> </html>
O.Curé [41 ] RDF Schema (RDFS) Un langage pour décrire des langages RDF. Permet de définir les types de ressources (personne, livre, etc.) ainsi que leurs propriétés (diplôme, titre, auteur, etc.). RDFS propose de l'information sur l'interprétation des déclarations RDF.
RDFS (2) Etendre RDF à la description d'ontologies. Hiérarchies de classes et propriétés : SubClassOf, subpropertyof range, domain sur les propriétés. Annotations seealso, isdefinedby, label, range, domain, member Préfixe : rdfs et URI : http://www.w3.org/2000/01/rdfschema# O.Curé [42 ]
O.Curé [43 ] Les primitives de RDFS Les primitives de RDF plus 16 nouvelles primitives (6 classes et 9 propriétés). Pour les classes :
O.Curé [44 ] Les primitives de RDFS (propriétés)
O.Curé [45 ] Classes et propriétés Une ressource peut-être une instance de plusieurs classes. Indication à l'aide de 'rdf:type'. La ressource http://www.univ-mlv.fr/~ocure est du type enseignant, personne, etc.. Enseignant est une sous-classe de personne. L'approche est centrée sur les propriétés.
O.Curé [46 ] Les classes rdf:property : une propriété est une ressource du type rdf:property. rdfs:class : Identique à la notion de classe en POO. rdfs:subclassof : indique un relation d'héritage.
O.Curé [47 ] Les propriétés rdf:type : indique qu'une ressource est un membre de cette classe. rdfs:subpropertyof : indique qu'une propriété est une spécialisation d'une autre propriété. rdfs:seealso : indique une propriété proposant des informations complémentaires.
O.Curé [48 ] Contraintes dans RDFS Spécifier domain et range sur les propriétés rdfs:range (le co-domaine) indique la classe à laquelle la valeur d'une propriété doit appartenir (rdf:class). rdfs:domain (le domaine) Indique la classe des membres de la propriété.
O.Curé [49 ] Documentation rdfs:comment : documentation (pour l'être humain) d'une ressource rdfs:label : description du nom d'une ressource.
O.Curé [50 ] Exemple - RDFS <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntaxns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"> <rdfs:class rdf:id= Personne > <rdfs:comment>la classe personne</rdfs:comment> </rdfs:class> <rdfs:class rdf:id= Vehicule > <rdfs:comment>la classe vehicule</rdfs:comment> </rdfs:class> <rdfs:class rdf:id= Voiture > <rdfs:comment>la classe voiture</rdfs:comment> <rdfs:subclassof rdf:resource= #Vehicule /> </rdfs:class> <rdf:property rdf:id= conducteur > <rdfs:domain rdf:resource= #Vehicule /> <rdfs:range rdf:resource= #Personne /> </rdf:property> </rdf:rdf>
O.Curé [51 ] Exemple RDF <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntaxns#" xmlns="http://www.univ-mlv.fr/~ocure/schemavehicule.rdf# > <Voiture rdf:id= vo001 > <conducteur> <Personne rdf:id= p101 /> </conducteur> </Voiture> <Voiture rdf:id= vo002 /> <conducteur> <Personne rdf:id= p102 /> </conducteur> </Voiture> </rdf:rdf>
O.Curé [52 ] Constats sur RDF(S) Puissance expressive insuffisante, il manque : Cardinalités (min et max) Décomposition (disjoint, exhaustivité). Axiomes Négation Ne permet pas de tester la consistance de la KB
O.Curé [53 ] RDF/RDFS problèmes Pas de distinctions entre classes et instances <Espece, type, Class> <Lion, type, Espece> <Simba, type, Lion> Les propriétés peuvent avoir des propriétés Pas de distinctions entre constructeurs du langage et les termes de l'ontologie.
O.Curé [54 ] Exercice Ecrire le document RDFS qui va définir les concepts suivants : une personne, un étudiant, un enseignant et un cours. Et les propriétés suivantes : estenseignant qui va retourner le nom d'un enseignant pour un cours donné, liste étudiants qui va rendre la liste des étudiants pour un cours donné, possèdenom, valable pour une personne et un cours et le co-domaine est alors une ressource du type : http://www.w3.org/1999/02/22-rdf-syntax-ns#literal. Ecrire un document respectant le schéma précédent pour ce cours. Valider avec le validateur RDF suivant : http://www.w3.org/rdf/validator/
O.Curé [55 ] Solution : RDFS (1) <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22- rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"> <rdfs:class rdf:id="personne"/> <rdfs:class rdf:id="etudiant"> <rdfs:subclassof rdf:resource="personne"/> </rdfs:class> <rdfs:class rdf:id="enseignant"> <rdfs:subclassof rdf:resource="personne"/> </rdfs:class> <rdfs:class rdf:id="cours"/> <rdfs:property rdf:id="estenseignant"> <rdfs:domain rdf:resource="#cours"/> <rdfs:range rdf:resource="#enseignant"/> </rdfs:property>
O.Curé [56 ] Solution : RDFS (2) <rdfs:property rdf:id="etudiantscours"> <rdfs:domain rdf:resource="#cours"/> <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdfsyntax-ns#seq"/> </rdfs:property> <rdfs:property rdf:id="possedenom"> <rdfs:domain rdf:resource= Cours /> <rdfs:domain rdf:resource="personne"/> <rdfs:range rdf:resource= "http://www.w3.org/1999/02/22-rdf-syntax-ns#literal"/> </rdfs:property> </rdf:rdf>
O.Curé [57 ] Solution : RDF (1) <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22- rdf-syntax-ns#" xmlns="http://www.univmlv.fr/~ocure/etudschema.rdf#"> <Cours rdf:id="cours2"> <possedenom>ontologie conception et realisation </possedenom> <estenseignant> <Enseignant rdf:id="oc"> <possedenom>olivier Cure</possedeNom> </Enseignant> </estenseignant> <etudiantscours>
O.Curé [58 ] Solution : RDF (2) <rdf:seq> <rdf:li> <Etudiant rdf:id="etud01"> <possedenom>pierre Dupont</possedeNom> </Etudiant> </rdf:li> <rdf:li> <Etudiant rdf:id="etud02"> <possedenom>ialain Durand</possedeNom> </Etudiant> </rdf:li> <rdf:li> <Etudiant rdf:id="etud03"> <possedenom>marie Martin</possedeNom> </Etudiant> </rdf:li> </rdf:seq> </etudiantscours> </Cours> </rdf:rdf>
O.Curé [59 ] Une autre version Toujours avec le même schéma, on veut maintenant ajouter le cours XML et Java du même enseignant et avec la même classe.
O.Curé [60 ] Solution 2 : RDF (1) <?xml version="1.0"?> <rdf:rdf xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://www.univ-mlv.fr/~ocure/etudschema.rdf#"> <Cours rdf:id="cours1"> <possedenom>xml et Java </possedenom> <estenseignant rdf:nodeid="oc"/> <etudiantscours rdf:nodeid="classeist"/> </Cours> <Cours rdf:id="cours2"> <possedenom>ontologie conception et realisation </possedenom> <estenseignant rdf:nodeid="oc"/> <etudiantscours rdf:nodeid="classeist"/> </Cours> <Enseignant rdf:nodeid="oc"> <possedenom>olivier Cure</possedeNom> </Enseignant>
O.Curé [61 ] Solution 2 : RDF (2) <rdf:seq rdf:nodeid="classeist"> <rdf:li> <Etudiant rdf:id="etud01"> <possedenom>pierre Dupont</possedeNom> </Etudiant> </rdf:li> <rdf:li> <Etudiant rdf:id="etud02"> <possedenom>alain Durand</possedeNom> </Etudiant> </rdf:li> <rdf:li> <Etudiant rdf:id="etud03"> <possedenom>marie Martin</possedeNom> </Etudiant> </rdf:li> </rdf:seq> </rdf:rdf>
O.Curé [62 ] Ok mais comment exploiter cela pour développer des applications?
O.Curé [63 ] 5 Exploiter RDF avec Jena
O.Curé [64 ] JENA : Présentation Plateforme Java pour le Web sémantique Open-source Développé par un laboratoire de Hewlett-Packard
O.Curé [65 ] JENA : URL La page d'accueil de JENA : http://jena.sourceforge.net/downloads.html Un groupe de discussions : http://groups.yahoo.com/group/jena-dev/ La javadoc http://jena.sourceforge.net/javadoc/index.html
O.Curé [66 ] JENA : éléments Un analyseur RDF : ARP Another RDF Parser un langage de requêtes pour RDF : RDQL RDF Query Language Persistence des données, en particulier avec les SGBD (Oracle, MySQL, PostgreSQL) Support de RDF, RDFS, OWL Inférence
O.Curé [67 ] Modèle L'architecture de JENA est centrée sur la notion de modèle (model) : l'ensemble des déclarations qui composent un document, graphe ou instanciation d'un vocabulaire. A partir de JENA2.0, on doit créer un modèle en s'aidant de ModelFactory.
O.Curé [68 ] ModelFactory : code import java.util.iterator; import com.hp.hpl.jena.rdf.model.*; public class EtudRDF { private String etudns ="file:/home/olive/_mescours/kr/etudins2.rdf"; public static void main(string[] args) { EtudRDF etudrdf= new EtudRDF(); etudrdf.load(); } public void load() { Model model = ModelFactory.createDefaultModel(); } } model.read(etudns); model.write(system.out);
O.Curé [69 ] Création / Enrichissement d'un modèle (1) model = ModelFactory.createDefaultModel(); jean = model.createresource(familleuri+"jean"); marie = model.createresource(familleuri+"marie"); dominique = model.createresource(familleuri+"dominique"); alexandra = model.createresource(familleuri+"alexandra"); baptiste = model.createresource(familleuri+"baptiste"); pierre = model.createresource(familleuri+"pierre"); enfantde = model.createproperty(relationshipuri,"childof"); parentde = model.createproperty(relationshipuri,"parentof"); epousede = model.createproperty(relationshipuri,"spouseof"); dominique.addproperty(parentde, baptiste); dominique.addproperty(parentde, pierre); alexandra.addproperty(parentde, baptiste); alexandra.addproperty(parentde,pierre); alexandra.addproperty(epousede, dominique);
O.Curé [70 ] Création / Enrichissement d'un modèle (2) Statement statement = model.createstatement(dominique, enfantde, jean); model.add(statement); statement = model.createstatement(dominique, enfantde, marie); model.add(statement); Property prop = model.createproperty(relationshipuri,"knowsof"); //Création d'un noeud vide Resource blank = model.createresource( ).addproperty(prop, "personne1").addproperty(prop, "personne2").addproperty(prop, model.createliteral("personne3", "fr")); // Affichage du document RDF au format RDF/XML (par défaut) model.write(new PrintWriter(System.out));
O.Curé [71 ] Accès aux données On peut accéder aux données : à l'aide de programmes en s'appuyant sur les méthodes et classes de l'api À l'aide de langage de requêtes RDQL.
O.Curé [72 ] Via les données : code // Ensemble des déclarations StmtIterator iter = model.liststatements(); while (iter.hasnext()) { } Statement stmt = (Statement) iter.next(); System.out.println(stmt.getSubject()+"- ("+stmt.getpredicate()+")- >"+stmt.getobject().tostring());
O.Curé [73 ] Via les données : code (2) // Connaitre les parents ResIterator parents = model.listsubjectswithproperty(parentde); while (parents.hasnext()) { personne = parents.nextresource(); System.out.println(personne.getLocalName()+ " -> URI ="+personne.geturi()); } // Encore des parents avec enfantde NodeIterator parentssuite = model.listobjectsofproperty(enfantde); while (parentssuite.hasnext()) { Resource person = (Resource) parentssuite.nextnode(); System.out.println( person.getlocalname()+ " -> URI ="+person.geturi()); }
O.Curé [74 ] Via les données : code (3) System.out.println("Les ens :"); NodeIterator itnode = model.listobjectsofproperty(estens); while (itnode.hasnext()) { RDFNode node = (RDFNode) itnode.next(); System.out.println("Enseignant ="+node.tostring()); // on veut le nom Property nom = model.createproperty("http://www.univmlv.fr/~ocure/etudschema.rdf#possedenom"); NodeIterator itnom = model.listobjectsofproperty((resource)node,nom); while (itnom.hasnext()) { System.out.println("Nom = "+itnom.next()); } }
O.Curé [75 ] Exercice 1 A partir du fichier RDF sur les cours, enseignants et etudiants : Afficher la liste des cours Afficher les enseignants, dans un premier temps le nom local des enseignants puis la valeur de l'attribut possedenom de chaque enseignant.
O.Curé [76 ] RDQL : présentation Syntaxe proche de SQL. Influence : SquishQL, RDFDB QL Les clauses sont : SELECT, WHERE, USING Les variables débutent par un?. Orienté données : les données explicites du modèle (pas implicites). Jena Tutorial : RDF provides a graph with directed edges - the nodes are resources or literals. RDQL provides a way of specifying a graph pattern that is matched against the graph to yield a set of matches. It returns a list of bindings - each binding is a set of name-value pairs for the values of the variables. All variables are bound (there is no disjunction in the query).
O.Curé [77 ] RDQL : le langage (1) BNF de RDQL à la page : http://jena.sourceforge.net/tutorial/rdql/rdql_grammar.html Exemple : SELECT * WHERE (?s,?p,?o) (s, 129d96a8:10160ffc9cc:-8000) (p, http://purl.org/vocab/relationship#knowsof) (o, personne2) (s, 129d96a8:10160ffc9cc:-8000) (p, http://purl.org/vocab/relationship#knowsof) (o, personne3~fr) (s, http://www.univ-mlv.fr/~ocure/rdf/famille#alexandra) (p, http://purl.org/vocab/relationship#parentof) (o, http://www.univmlv.fr/~ocure/rdf/famille#pierre) (s, http://www.univ-mlv.fr/~ocure/rdf/famille#alexandra) (p, http://purl.org/vocab/relationship#parentof) (o, http://www.univmlv.fr/~ocure/rdf/famille#baptiste) (s, http://www.univ-mlv.fr/~ocure/rdf/famille#dominique) (p, http://purl.org/vocab/relationship#parentof) (o, http://www.univmlv.fr/~ocure/rdf/famille#pierre) (s, http://www.univ-mlv.fr/~ocure/rdf/famille#dominique) (p, http://purl.org/vocab/relationship#parentof) (o, http://www.univmlv.fr/~ocure/rdf/famille#baptiste)...
O.Curé [78 ] RDQL : le langage (2) SELECT * WHERE (?s,<rel:parentof>,?o) USING rel FOR < http://purl.org/vocab/relationship#> SELECT?s WHERE (?s,<rel:parentof>,?o) USING rel FOR < http://purl.org/vocab/relationship#> Résultats : alexandra parent de pierre alexandra parent de baptiste dominique parent de pierre dominique parent de baptiste
O.Curé [79 ] RDQL : le langage (3) "SELECT?o,?o2 WHERE (?s,<rel:childof>,?o), (? s,<rel:parentof>,?o2) USING rel FOR rel FOR < http://purl.org/vocab/relationship#> Résultats : marie parent de pierre marie parent de baptiste jean parent de pierre jean parent de baptiste
O.Curé [80 ] RDQL : filtre On peut filtrer les valeurs des variables à l'aide de la clause AND. Exemple : AND?age > 18 On apeut aussi profiter des expressions régulières ( =~ egalité et!~ différence). Exemple : SELECT * WHERE (?s,<rel:parentof>,?o) AND?s =~ /dominique/i USING rel FOR < http://purl.org/vocab/relationship#> dominique parent de pierre dominique parent de baptiste Insensible à la casse
O.Curé [81 ] RDQL :programmation Java Mode de fonctionnement : On passe la requête à un objet instancié de la classe Query. On passe alors l'objet à un objet du type QueryEngine. Les résultats se trouvent dans un objet du type QueryResults On accède aux résultats via la classe ResultBinding Query qr1 = new Query("SELECT * WHERE (?s,?p,?o)"); qr1.setsource(model); QueryEngine qe = new QueryEngine(qr1); QueryResults results = qe.exec(); for(it=results; it.hasnext();) { ResultBinding res = (ResultBinding)it.next() ; } String x = (res.get("s").tostring()); String y = res.get("o").tostring(); System.out.println(x.substring(x. indexof('#')+1) +" parent de "+y.substring(y.indexof('#')+1));
O.Curé [82 ] Exercice 2 Toujours le fichier RDF de l'exercice 1, rédiger les requêtes RDQL suivantes : Afficher les cours Afficher les étudiants Afficher les enseignants Afficher l'enseignant du Cours1
O.Curé [83 ] Opérations sur les modèles On peut réaliser les opérations ensemblistes suivantes sur les modèles : union, intersection et différence. Exemple pour l'union Model modeli = ModelFactory.createDefaultModel(); modeli.read(instns); Model models = ModelFactory.createDefaultModel(); models.read(schemans); Model model = models.union(modeli); model.write(system.out); Idem pour intersection et difference
O.Curé [84 ] Inférence Jena propose de nombreuses fonctionnalités pour réaliser des inférences. Lire le document Inference engine user manual accessible depuis la page Documentation du site de Jena.
O.Curé [85 ] Exercice 3 Sur le fichier RDFS (schemaetud.rdf) afficher toutes les sous-classes de la classe Personne Rédiger une classe Thesard, sousclasse de la classe Etudiant. Demander à nouveau les sous-classes de la classe Personne.
O.Curé [86 ] Exercice 4 Réaliser l'union du modèle du schéma RDF et du modèle des instances RDF. Ecrire le code permettant d'obtenir les instances de la classe Etudiant puis Enseignant. Ecrire un modèle permettant l'inférence et écrire le code permettant d'obtenir les instances de la classe Personne.
SPARQL O.Curé [87 ]
O.Curé [88 ] Introduction Query language for RDF data Basic graph pattern matching Result forms: SELECT, CONSTRUCT, DESCRIBE, ASK with filters to restrict values Solution modifiers: ORDER BY, LIMIT/OFFSET, DISTINCT, REDUCED
O.Curé [89 ] Patterns Variables are prefixed with a '?' Patterns use triple forms Example: SELECT?s?p?o WHERE {?s?p?o} A pattern is a conjunction of triples: {?x rdf:type ex:person.?x ex:nom?name}
O.Curé [90 ] Example @prefix person: <http://example/person/>. @prefix foaf: <http://xmlns.com/foaf/0.1/>. person:a foaf:name "Alice". person:a foaf:mbox <mailto:alice@example.net>. person:b foaf:name "Bob". PREFIX person: <http://example/person/> PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT?name WHERE {?x foaf:name?name } name ----------- "Bob" "Alice"
O.Curé [91 ] Example (2) @prefix person: <http://example/person/>. @prefix foaf: <http://xmlns.com/foaf/0.1/>. person:a foaf:name "Alice". person:a foaf:mbox <mailto:alice@example.net>. person:b foaf:name "Bob". PREFIX person: <http://example/person/> PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT?name WHERE {?person foaf:mbox <mailto:alice@example.net>.?person foaf:name?name. } name ----------- "Alice"
O.Curé [92 ] Example (3a) @prefix dc: <http://purl.org/dc/elements/1.1/>. @prefix stock: <http://example.org/stock#>. @prefix inv: <http://example.org/inventory#>. stock:book1 dc:title "SPARQL Query Language Tutorial". stock:book1 inv:price 10. stock:book1 inv:quantity 3. stock:book2 dc:title "SPARQL Query Language (2nd ed)". stock:book2 inv:price 20 ; inv:quantity 5. stock:book3 dc:title "Moving from SQL to SPARQL". stock:book3 inv:price 5 ; inv:quantity 0. stock:book4 dc:title "Applying XQuery". stock:book4 inv:price 20 ; inv:quantity 8.
O.Curé [93 ] Example (3b) PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX stock: <http://example.org/stock#> PREFIX inv: <http://example.org/inventory#> SELECT?book?title WHERE {?book dc:title?title.?book inv:price?price. FILTER (?price < 15 )?book inv:quantity?num. FILTER (?num > 0 ) } book title ----------------------------------------------------------------------------------- stock:book1 "SPARQL Query Language Tutorial"
O.Curé [94 ] Example (4) @prefix person: <htp://example/person/> t. @prefix foaf: <http://xmlns.com/foaf/0.1/>. person :a foaf:name "Alice". person :a foaf:nick "A-online". person:b foaf:name "Bob". PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT?name?nick {?x foaf:name?name. OPTIONAL {?x foaf:nick?nick } } name nick ------------------------------ "Alice" "A-online" "Bob