RDF : Resource Description Framework

author:Pierre-Antoine Champin

Motivation et historique

Le Web vu par Tim Berners-Lee (1989)

« Vague, but exciting »

source: http://info.cern.ch/images/proposal.gif

Web de ressources

Le web est constitué de ressources:

• chaque ressource est identifiée par un URI (Uniform Resource Identifier), e.g.:

  • http://meteo.example.com/lyon
  • http://meteo.example.com/ici
  • http://commerce.example.com/commande/192837

  NB: ressource ≠ fichier !

• chaque ressource a un état qui peut varier dans le temps

  • cet état n’est jamais manipulé directement, mais toujours à travers des représentations

Ressources et représentations

• À chaque état d’une ressource peuvent correspondre une ou plusieurs représentation(s) (négociation de contenu, contexte)

• Toute interaction avec une ressource se fait via des représentation :

  consultation, modification, création

représentation :	utilisable par :
texte	humains, moteurs de recherche
médias (image, son...)	surtout humains
données structurées	machines

De HTML à XML

XML (eXtensible Markup Language) a été recommandé par le W3C en 1998. L’objectif était de pallier la sémantique « faible » de HTML.

<!-- HTML -->
<a href="http://champin.net/">
  Pierre-Antoine <strong>Champin</strong>
  (<em>Maître de conférences</em>)</a>

<!-- XML -->
<Person homepage="http://champin.net/">
  <givenName>Pierre-Antoine</givenName>
  <surname>Champin</surname>
  <job>Maître de conférences</job></Person>

XML et la sémantique

On a dit tout et son contraire l’apport sémantique de XML :

• XML a plus de sémantique que HTML,
• XML a moins de sémantique que HTML,

Les deux ont leur part de vérité.

XML a plus de sémantique que HTML...

... dans le sens ou il est extensible : on eut donc exprimer des choses que HTML ne permet pas d’exprimer (e.g.``<firstname>``).

• Importance des espaces de noms, qui évitent les collisions de noms et fournissent ainsi une sémantique « structuraliste » (i.e. par différentiation).

<Person xmlns="http://xmlns.com/foaf/0.1/"
        xmlns:pro="http://example.com/"
     homepage="http://champin.net/">
  <givenName>Pierre-Antoine</givenName>
  <surname>Champin</surname>
  <pro:job>Maître de conférence</pro:job></Person>

XML a moins de sémantique que HTML...

... dans la mesure ou :

• un navigateur standard ne saura pas quoi faire de la balise <firstname> ou de la balise <ονομα>,
  • tout au plus il saura les afficher s’il possède une feuille de style,
• tandis qu’il connaît la sémantique de la balise <em> : elle dénote un texte à mettre en évidence selon les moyens dont il dispose, par exemple :
  • en le mettant en italique (standard)
  • en le mettant en gras (police déjà en italique)
  • en le mettant en couleurs (police sans italique, terminal)
  • en marquant une pause (synthèse vocale)

XML : apports et limitations

Le surplus de sémantique promis par XML n’est donc pas « magique » : il suppose

• de créer de nouveaux langages basés sur XML (DTD, schémas),

• d’écrire les logiciels qui interpréteront ces nouveaux langages,

  → chaque langage reste relativement idiosyncratique.

XML : apports et limitations (suite)

L’apport est donc essentiellement technique : la base commune de XML permet de factoriser les efforts de développement et d’apprentissage :

• analyseurs syntaxiques (parsers),
• langages de schéma (DTD, XML-Schema, Relax-NG...),
• langages de requêtes (XPath, XQuery),
• langages de transformation (XSL-T),
• méthode de signature cryptographique (xmldsig),
• methode de compression (EXI)...

De XML à RDF

• Le modèle sous-jacent de la syntaxe XML est un arbre (XML Infoset), ce qui n’est pas adapté à la structure décentralisée du Web.

• L’objectif du Resource Description Framework (RDF), recommandé par le W3C en 1999, vise à munir le Web d’un modèle de données plus adapaté, ayant une structure de graphe.

• L’objectif est de construire le Semantic Web : un web dans lequel les machines ont (enfin) accès à la sémantique des données.

• Recommandation un peu hâtive, présentant quelques défauts importants (notamment l’absence de sémantique formelle).

  → faible adoption de RDF

De RDF à RDF

• En 2004, le W3C publie un nouvel ensemble de recommandations sur RDF pour remplacer celles de 1999.
• Pour des raisons de compatibilité avec l’existant, certains aspects sont conservés malgré les débats qu’ils suscitent, mais les défauts considérés comme majeurs sont corrigés.
• Après cet échec relatif, l’appellation Semantic Web tombe peu a peu en disgrâce. Certains défenseurs de RDF parlent plus modestement de Data Web, puis de Web of Linked Data (2006).

source: http://www.w3.org/RDF/icons/

Syntaxe(s) et sémantique

RDF 2004 définit :

• une syntaxe abstraite (modèle de donnée),
• une sémantique pour interpréter la syntaxe abstraite,
• plusieurs syntaxes concrètes pour représenter/échanger la syntaxe abstraite.

Syntaxe abstraite

Triplet

Toute information en RDF est représentée par un triplet :

Le laboratoire LIRIS (sujet)

a pour membre (prédicat)

Pierre-Antoine Champin (objet)

Nommage

Les choses sont nommées par des URIs :

http://liris.cnrs.fr/#lab

http://xmlns.com/foaf/0.1/member

http://champin.net/#pa

On peut représenter ceci graphiquement :

Remarque

Dans RDF, les URIs ne sont utilisés que comme des identifiants opaques.

Les représentations qui sont éventuellement accessibles via ces URIs (par déréférencement) n’ont aucune influence sur leur sémantique.

Notons cependant que le mouvement Linked data préconise une utilisation particulière des URIs dans laquelle les réprésentations doivent être cohérentes avec la sémantique.

Préfixes

Pour simplifier les notations, on définit des préfixes courts correspondant à des préfixes d’URI :

liris: → http://liris.cnrs.fr/#

foaf: → http://xmlns.com/foaf/0.1/

champin: → http://champin.net/#

On utilise ensuite des noms préfixés :

liris:lab   foaf:member   champin:pa

et également sous forme graphique :

Littéraux

On peut également lier une ressource à une donnée typée (chaîne de caractère, entier, réel...), nommée un littéral.

champin:pa   foaf:name   “Pierre-Antoine Champin”

Traditionnellement, on représente les littéraux par des nœuds rectangulaires :

Nœuds vierges

Enfin, RDF permet de parler d’une ressource sans connaître son URI. Cela revient en logique à utiliser une variable quantifiée existentiellement.

(quelque chose)   foaf:name   “Alain Mille”

Graphiquement, on représente cette ressource par un nœud vierge (blank node).

Exemple de graphe

Sémantique

Principe général

RDF est muni d’une sémantique en théorie des modèles, ou sémantique dénotationnelle :

• chaque nœud du graphe dénote une ressource (NB : les littéraux sont considéré comme des ressources particulières),
• chaque ressource peut être associée à une relation binaire entre ressources,
• chaque arc signifie que les ressources dénotés par les nœuds vérifient la relation associée à (la ressource dénotée par) l’URI de l’arc

Inférences

De cette sémantique découlent les inférences que l’ont peut faire sur un graphe RDF (indépendamment de la sémantique des URIs utilisés dans ce graphe).

• Par analogie, les seules inférences que l’on puisse faire sur un arbre XML indépendamment des termes utilisés sont de changer l’ordre des attributs, et de changer les préfixes (si l’on considère les espaces de noms).

Monotonie

Étant donné un graphe, tout sous-graphe en est une conséquence.

Monotonie (suite)

Aucune conclusion que l’on peut tirer d’un graphe RDF ne peut pas être contredite par des informations présentes ailleurs sur le Web.

→ On est donc toujours en droit de fusionner des graphes RDF, même provenant de sources indépendantes

Anonymisation

Tout nœud peut être remplacé par un nœud vierge :

(rappel : les nœuds vierges s’interpètent comme des variables quantifiées existentiellement)

Éclatement

Tout nœud vierge peut être éclaté en plusieurs nœuds vierges :

Sémantique additionelle

Bien sûr, des inférences supplémentaires peuvent être faites en prêtant une sémantique particulière aux URIs utilisés dans le graphe,

• par exemple en décidant qu’une relation binaire est symétrique ou transtitive.

Cependant, cette sémantique devra respecter la sémantique dénotationnelle de RDF ; notamment, les inférences supplémentaires ne devront pas contredire les inférences précédente (monotonie) :

• sans quoi les outils ne connaissant pas cette sémantique particulière tireront des conclusions erronées.

Sémantique additionelle (suite)

On verra plus tard des langages (RDF-Schema, OWL) permettant de définit la sémantique de certains URIs.

Analogie : lorsqu’on définit un format XML, on prête une sémantique particulière aux éléments et attributs de ce format, mais on ne peut pas prêter de sémantique à l’ordre des attributs ;

• sémantiquement, ce ne serait plus du XML,
• pragmatiquement, les outils standards (analyseur syntaxique, sérialiseurs) ne permettraient pas de contrôler cet aspect de la syntaxe.

Syntaxes concrètes

RDF/XML

• première syntaxe recommandée par le W3C (1999)
• basée sur XML
• relativement complexe et verbeuse

Syntaxe:http://www.w3.org/TR/rdf-syntax-grammar/ Valideur:http://www.w3.org/RDF/Validator/

RDF/XML : exemple

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:foaf="http://xmlns.com/foaf/0.1/"                          >
 <foaf:Group rdf:about="http://liris.cnrs.fr/#lab">
  <foaf:member>
   <foaf:Person>
    <foaf:name>Alain Mille</foaf:name>
    <foaf:knows
     rdf:resource="http://champin.net/#pa"/>
   </foaf:Person>
  </foaf:member>
  <foaf:member>
   <foaf:Person rdf:about="http://champin.net/#pa">
    <foaf:name>Pierre-Antoine Champin</foaf:name>
   </foaf:Person>
  </foaf:member>
  </foaf:Group>
</rdf:RDF>

Turtle : Terse RDF Triple Language

• dérivée du langage N3
• recommandé par le W3C en 2014
• vise la simplicité et la compacité

Syntaxe:http://www.w3.org/TR/turtle/

Turtle: exemple

@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix champin: <http://champin.net/#> .

liris:lab
    a foaf:Group ;
    foaf:member champin:pa, _:am .
champin:pa
    a foaf:Person ;
    foaf:name "Pierre-Antoine Champin" .
_:am
    a foaf:Person ;
    foaf:name "Alain Mille" ;
    foaf:knows champin:pa .

Turtle: exemple 2

@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix champin: <http://champin.net/#> .

liris:lab
    a foaf:Group ;
    foaf:member champin:pa, [
      a foaf:Person ;
      foaf:name "Alain Mille" ;
      foaf:knows champin:pa .
    ] .
champin:pa
    a foaf:Person ;
    foaf:name "Pierre-Antoine Champin" .

RDFa : RDF in attributes

RDFa est une utilisation d’attributs (existants ou supplémentaires) de (X)HTML pour y inclure du RDF (à la manière des micro-formats) :

• facilite la migration de contenus HTML vers RDF
• facilite la maintenance en cohérence de la version HTML et des données RDF (DRY : Don’t Repeat Yourself)

Syntaxe:http://www.w3.org/TR/rdfa-primer/ Valideur:http://check.rdfa.info/ Distiller:http://www.w3.org/2012/pyRdfa/

RDFa : exemple

<p prefix="foaf http://xmlns.com/foaf/0.1/"
   about="_:am">
  <span property="foaf:name"
    >Alain Mille</span>
  est membre du
  <a rev="foaf:member" href="http://liris.cnrs.fr/#lab"
    >LIRIS</a>.
  Il connaît
  <span rel="foaf:knows" href="http://champin.net/#pa">
    <span property="foaf:name"
      >Pierre-Antoine Champin</span>,
    un autre membre de
    <span rev="foaf:member" href="http://liris.cnrs.fr/#lab">
      ce laboratoire.</span>
  </span> </p>

JSON-LD

• Rappel : JSON est un langage d’échange de données, basé sur Javascript, et très utilisé en développement web.
• JSON-LD (JSON Linked Data) permet d’interpreter une structure JSON comme du RDF,
• grâce à un contexte (implicite ou explicite).
• Objectif : faciliter l’adoption de RDF (syntaxe abstraite) auprès des développeurs d’applications web.

Syntaxe:http://www.w3.org/TR/json-ld-syntax/ Valideur:http://json-ld.org/playground/

JSON-LD: exemple

{ "@context" : { /* ... */                                   },
 "@id": "http://liris.cnrs.fr/#lab",
 "@type": "Group",
 "member": [
   {
     "@id": "http://champin.net/#pa",
     "@type": "Person",
     "name": "Pierre-Antoine Champin"
   },
   {
     "@type": "Person",
     "name": "Alain Mille",
     "knows": "http://champin.net/#pa"
   }
 ]
}

Autres syntaxes

• Comme l’illustrent RDFa et JSON-LD, tout langage peut être interprété comme du RDF:
  • dialectes en XML (GRDDL)
  • microformats (http://http://microformats.org/)
  • microdata (http://www.data-vocabulary.org/)
• ← Prépondérance de la syntaxe abstraite.
• Difficulté : faire correspondre des URIs là ou d’autres langages utilisent des termes « locaux ».

Dataset et requêtes

Dataset

Lorsqu’on stocke des données en RDF, il est parfois nécessaire de distinguer plusieurs graphes.

Un dataset RDF est constitué :

• d’un graphe par défaut,

• d’un ensemble de couples <URI, Graphe>

  ⚠ aucune relation sémantique imposée entre l’URI et le graphe

SPARQL

SPARQL est un ensemble de recommandations définissant :

• un langage d’interrogation d’un dataset (SPARQL)
• un langage de mise à jour d’un dataset (SPARQL-update ou SPARUL)
• un protocole REST-like pour envoyer des requêtes SPARQL à un dataset

Référence:http://w3.org/sparql Tutoriel:http://jena.sourceforge.net/ARQ/Tutorial/

SPARQL : exemple 1

« Trouver les membres du LIRIS (URI et nom) que je connaît ».

PREFIX foaf: <http://xmlns.com/foaf/0.1.> #...

SELECT ?p ?n
WHERE {
  champin:pa foaf:knows ?p .
  liris:lab foaf:member ?p .
  ?p foaf:name ?n .
}

SPARQL : exemple 2

« Construire l’union des graphes créés par Pierre-Antoine Champin ».

PREFIX dct: <http://purl.org/dc/terms/>

CONSTRUCT { ?s ?p ?o }
WHERE {
  ?g dct:creator <http://champin.net/#pa> .
  GRAPH ?g { ?s ?p ?o }
}

⚠ pré-supposition sur la sémantique des URIs des graphes

SPARUL : exemple

« Remplacer foaf:firstName par foaf:givenName pour tous les membres du LIRIS ».

PREFIX foaf: <http://xmlns.com/foaf/0.1.>

DELETE {
  ?m foaf:firstName ?n .
}
INSERT {
  ?m foaf:givenName ?n .
}
WHERE {
  <http://liris.cnrs.fr/#lab> foaf:member ?m .
  ?m foaf:givenName ?n .
}