RDF - Index of

Transcription

RDF - Index of

4
Le web sémantique
O.Curé [1 ]
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é [2 ]
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é [3 ]
L'architecture du web
sémantique
O.Curé [4 ]
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.
O.Curé [5 ]
RDF et RDFS
O.Curé [6 ]
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é [7 ]
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.
O.Curé [8 ]
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 ]
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é [11 ]
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, Ntriples, graphique).
Exprime des faits simples
O.Curé [12 ]
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é [13 ]
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é [14 ]
Sérialisation XML/RDF
●
Code XML/RDF :
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdf
syntaxns#"
xmlns:dc="http://purl.org/dc/elements/1.1/">
<rdf:Description rdf:about="http://www.univ
mlv.fr/~ocure">
<dc:title>Page de olivier Cure</dc:title> <dc:author>Olivier Cure</dc:author> </rdf:Description>
</rdf:RDF>
O.Curé [15 ]
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.univmlv.fr/~ocure> <http://purl.org/dc/elements/1.1/title> "Page de olivier Cure" .
<http://www.univmlv.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/22rdf
syntaxns#> .
<http://www.univmlv.fr/~ocure> dc:author "Olivier Cure";
dc:title "Page de olivier Cure" .
Génération : http://www.mindswap.org/2002/rdfconvert/
O.Curé [17 ]
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.univmlv.fr/~ocure/rsrc#"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntaxns#">
mlv.fr/~ocure">
<dc:author>Olivier Cure</dc:author>
<dc:title>Page Web de Olivier Cure</dc:title>
<rsrc:univ rdf:resource="http://www.univmlv.fr"/>
</rdf:Description>
<rdf:Description rdf:about="http://www.univmlv.fr">
<rsrc:propb>valeur propb</rsrc:propb>
</rdf:Description>
</rdf:RDF>
O.Curé [18 ]
Liaisons entre déclarations
O.Curé [19 ]
On pouvait aussi écrire
<rdf:RDF xmlns:rsrc="http://www.univmlv.fr/~ocure/rsrc#"
xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntaxns#">
mlv.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.univmlv.fr">
<rsrc:propb>valeur propb</rsrc:propb>
</rdf:Description>
</rsrc:univ>
</rdf:Description>
</rdf:RDF>
O.Curé [20 ]
Sérialisation XML
●
Racine RDF et espace de nommage
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22
rdfsyntaxns#">
...
</rdf:RDF>
O.Curé [21 ]
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
syntaxns#">
<rdf:Description about=”http://www.univmlv.fr/~ocure”>
...
</rdf:Description>
</rdf:RDF>
O.Curé [22 ]
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.
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntaxns#"
xmlns:dc=”http://purl.org/dc/elements/1.1/”>
<dc:creator>Olivier Curé</dc:creator>
</rdf:Description>
</rdf:RDF>
O.Curé [23 ]
Ressources multiples
<rdf:Description about=”http://www.univmlv.fr/~ocure/enseignement/IST”>
<dc:title>Page sur l'enseignement en Master 2 IST</dc:title>
<dc:date>20040101</dc:date>
</rdf:Description>
<rdf:Description about=”http://www.univmlv.fr/~ocure/enseignement/Ing2000”>
<dc:title>Page sur l'enseignement Ingenieurs 2000</dc:title>
</rdf:Description>
</rdf:RDF>
O.Curé [24 ]
Imbrication de ressources
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntaxns
#"
xmlns:dc=”http://purl.org/dc/elements/1.1/”
xmlns:vcard=”http://imc.org/vCard/3.0#”>
<rdf:Description about=”http://www.univmlv.fr/~ocure
/enseignement/IST”>
<dc:creator>
<vcard:FN>Olivier Curé</vcard:FN>
<vcard:EMAIL>ocure@univmlv.fr</vcard:EMAIL>
</dc:creator>
</rdf:Description>
</rdf:RDF>
O.Curé [25 ]
Références entre
ressources
xmlns:dc=”http://purl.org/dc/elements/1.1/”
xmlns:vcard=”http://imc.org/vCard/3.0#”>
<rdf:Description about=”http://www.univmlv.fr/~ocure/enseignement/
IST”>
<dc:creator rdf:resource=”http://www.univmlv.fr/~ocure”/>
</rdf:Description>
</rdf:Description>
</rdf:RDF>
Faire référence à un objet décrit dans le
document.
O.Curé [26 ]
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 ]
Blank nodes (2)
●
En RDF/XML, on fait référence à un
noeud vide à l'aide de l'attribut:
rdf:nodeId
O.Curé [28 ]
Blank node exemple
syntaxns#"
xmlns:exterms="http://www.example.org/terms/">
mlv.fr/~ocure">
<exterms:pred1 rdf:nodeID="x1"/>
</rdf:Description>
mlv.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>
O.Curé [29 ]
Comme un graphe
O.Curé [30 ]
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é [31 ]
rdf:Bag exemple
<rdf:Description about=”urn:ISBN:0666123457”>
<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>
O.Curé [32 ]
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 ]
Réification – le code
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntax
ns#"
xmlns:s="http://www.schemas.org/schema/">
<rdf:Description>
<rdf:subject rdf:resource="http://www.univ
mlv.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
rdfsyntaxns#Statement"/>
<s:attributedTo>Gabriella</s:attributedTo>
</rdf:Description>
</rdf:RDF>
O.Curé [34 ]
Réification – le graphe
O.Curé [35 ]
Syntaxe abrégée
●
On peut convertir les propriétés en attributs
<dc:title>Page sur l'enseignement en Master 2 IST</dc:title>
</rdf:Description>
●
devient
/enseignement/IST” dc:creator=”Olivier Curé” dc:title=”Page sur l'enseignement en Master 2 IST” dc:date=”20040101”/>
O.Curé [36 ]
Syntaxe abrégée (2)
●
La description d'un élément imbriqué peut être
réécrit à l'aide d'attributs
<dc:creator>
</rdf:Description>
</dc:creator>
</rdf:Description>
●
devient
<dc:creator rdf:resource=”http://www.univmlv.fr/~ocure” vcard:FN=”Olivier Curé” vcard:EMAIL=”ocure@univmlv.fr“/>
</rdf:Description>
O.Curé [37 ]
Syntaxe abrégée (3)
●
La valeur d'un rdf:type devient un élément
<rdf:Description about="http://www.univmlv.fr/~ocure/">
<rdf:type rdf:resource="http://www.schemas.org/www/Webpage"/>
<dc:title>Programmation Java XML</dc:title>
</rdf:Description>
</rdf:RDF>
●
Devient
xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:s="http://www.schemas.org/www/">
<s:Webpage about="http://www.univmlv.fr/~ocure/"
dc:creator=”Olivier Curé” dc:title=”Programmation Java XML” dc:date=”20040101”/>
</rdf:RDF>
O.Curé [38 ]
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é [39 ]
Du RDF dans du HTML
<html>
<head>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntax
ns#"
<rdf:Description about=""
dc:creator="Olivier Curé"
dc:title="Programmation Java et XML"
dc:date="20041010"/>
</rdf:RDF>
<title>Programmation Java et XML pour les M2 IST</title>
</head>
<body>
.
.
.
</body>
</html>
O.Curé [40 ]
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.
O.Curé [41 ]
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/rdf-schema#”
O.Curé [42 ]
Les primitives de RDFS
●
●
Les primitives de RDF plus 16 nouvelles
primitives (6 classes et 9 propriétés).
Pour les classes :
O.Curé [43 ]
Les primitives de RDFS
(propriétés)
O.Curé [44 ]
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é [45 ]
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é [46 ]
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é [47 ]
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é [48 ]
Documentation
●
●
rdfs:comment : documentation (pour
l'être humain) d'une ressource
rdfs:label : description du nom d'une
ressource.
O.Curé [49 ]
Exemple - RDFS
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntax
ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdfschema#">
<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é [50 ]
Exemple RDF
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntax
ns#"
xmlns="http://www.univmlv.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é [51 ]
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é [52 ]
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é [53 ]
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é [54 ]
Solution : RDFS (1)
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22
rdfsyntaxns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdfschema#">
<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é [55 ]
Solution : RDFS (2)
<rdfs:Property rdf:ID="etudiantsCours">
<rdfs:domain rdf:resource="#Cours"/>
<rdfs:range rdf:resource="http://www.w3.org/1999/02/22rdf
syntaxns#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/22rdfsyntaxns#Literal"/>
</rdfs:Property>
</rdf:RDF>
O.Curé [56 ]
Solution : RDF (1)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22
rdfsyntaxns#" xmlns="http://www.univ
mlv.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é [57 ]
Solution : RDF (2)
<rdf:Seq>
<rdf:li>
<Etudiant rdf:ID="etud01">
<possedeNom>Pierre Dupont</possedeNom>
</Etudiant>
</rdf:li>
<rdf:li>
<possedeNom>iAlain Durand</possedeNom>
</Etudiant>
</rdf:li>
<rdf:li>
<possedeNom>Marie Martin</possedeNom>
</Etudiant>
</rdf:li>
</rdf:Seq>
</etudiantsCours>
</Cours>
</rdf:RDF> O.Curé [58 ]
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é [59 ]
Solution 2 : RDF (1)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22rdfsyntaxns#" xmlns="http://www.univmlv.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é [60 ]
Solution 2 : RDF (2)
<rdf:Seq rdf:nodeID="classeIST"> <rdf:li>
<possedeNom>Pierre Dupont</possedeNom>
</Etudiant>
</rdf:li>
<rdf:li> <Etudiant rdf:ID="etud02">
<possedeNom>Alain Durand</possedeNom>
</Etudiant>
</rdf:li> <rdf:li>
<possedeNom>Marie Martin</possedeNom>
</Etudiant>
</rdf:li>
</rdf:Seq>
</rdf:RDF> O.Curé [61 ]
●
Ok mais comment exploiter cela pour
développer des applications ?
O.Curé [62 ]
5
Exploiter RDF avec Jena
O.Curé [63 ]
JENA : Présentation
●
●
●
Plateforme Java pour le Web
sémantique
Open-source
Développé par un laboratoire de
Hewlett-Packard
O.Curé [64 ]
JENA : URL
●
La page d'accueil de JENA :
–
●
Un groupe de discussions :
–
●
http://jena.sourceforge.net/downloads.html
http://groups.yahoo.com/group/jena-dev/
La javaDoc
–
http://jena.sourceforge.net/javadoc/index.html
O.Curé [65 ]
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é [66 ]
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é [67 ]
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é [68 ]
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é [69 ]
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é [70 ]
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é [71 ]
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é [72 ]
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é [73 ]
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.univ
mlv.fr/~ocure/etudSchema.rdf#possedeNom");
NodeIterator itNom = model.listObjectsOfProperty((Resource)node,nom);
while (itNom.hasNext()) {
System.out.println("Nom = "+itNom.next());
}
}
O.Curé [74 ]
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é [75 ]
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é [76 ]
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.univmlv.fr/~ocure/rdf/famille#alexandra) (p, http://purl.org/vocab/relationship#parentOf) (o, http://www.univ
mlv.fr/~ocure/rdf/famille#pierre)
(s, http://www.univmlv.fr/~ocure/rdf/famille#alexandra) (p, http://purl.org/vocab/relationship#parentOf) (o, http://www.univ
mlv.fr/~ocure/rdf/famille#baptiste)
(s, http://www.univmlv.fr/~ocure/rdf/famille#dominique) (p, http://purl.org/vocab/relationship#parentOf) (o, http://www.univ
mlv.fr/~ocure/rdf/famille#pierre)
(s, http://www.univmlv.fr/~ocure/rdf/famille#dominique) (p, http://purl.org/vocab/relationship#parentOf) (o, http://www.univ
mlv.fr/~ocure/rdf/famille#baptiste)
...
O.Curé [77 ]
●
●
●
SELECT * WHERE (?s,<rel:parentOf>,?o) USING rel FOR <
http://purl.org/vocab/relationship#>
SELECT ?s WHERE (?s,<rel:parentOf>,?o) USING rel FOR <
Résultats :
alexandra parent de pierre
alexandra parent de baptiste
dominique parent de pierre
dominique parent de baptiste
O.Curé [78 ]
●
●
"SELECT ?o, ?o2 WHERE (?s,<rel:childOf>,?o), (?
s,<rel:parentOf>,?o2) USING rel FOR rel FOR <
Résultats :
marie parent de pierre
marie parent de baptiste
jean parent de pierre
jean parent de baptiste
O.Curé [79 ]
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 <
dominique parent de pierre
dominique parent de baptiste
Insensible à
la casse
O.Curé [80 ]
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é [81 ]
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é [82 ]
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é [83 ]
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é [84 ]
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é [85 ]
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.
O.Curé [86 ]
SPARQL
O.Curé [87 ]
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é [88 ]
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é [89 ]
Example
@prefix person: <http://example/person/> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
person:A foaf:name "Alice" .
person:A foaf:mbox <mailto:[email protected]> .
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é [90 ]
Example (2)
@prefix person: <http://example/person/> .
person:A foaf:name "Alice" .
person:A foaf:mbox <mailto:[email protected]> .
person:B foaf:name "Bob" .
PREFIX person: <http://example/person/>
SELECT ?name
WHERE { ?person foaf:mbox
<mailto:[email protected]> .
?person foaf:name ?name . }
name
----------"Alice"
O.Curé [91 ]
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:book4 dc:title "Applying XQuery" .
O.Curé [92 ]
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é [93 ]
Example (4)
@prefix person: <htp://example/person/>
.
t
person :a foaf:name "Alice" .
person :a foaf:nick "A-online" .
person:b foaf:name "Bob" .
SELECT ?name ?nick
{ ?x foaf:name ?name .
OPTIONAL {?x foaf:nick ?nick } }
name | nick
-----------------------------"Alice" | "A-online"
"Bob |
O.Curé [94 ]

RDF - Index of

Transcription

Documents pareils

Exercices 1 – RDF, RDF-Schema

Étapes d`implantation d`un projet de Web de données en milieu

Clifford Chance

Document search Mediator

Guy Lapalme - Université de Montréal

Moteur de recherche Swoogle

Clifford Chance

17 - Texto : textes et cultures

Modification de la formule de calcul de la réduction Fillon