Travaux pratiques (LODAS version salle TP)

1 TP – XPath

1.1 Préparation (en salle TP)

Vous pouvez copiez/coller le texte sur un fond coloré dans un terminal Linux pour l’exécuter :

  • Mise-à-jour de l’environnement Linux: 
    source /Infos/bd/dm/asws/public/config
  • Créer un répertoire $HOME/asws: 
    mkdir $HOME/asws
  • On suppose que vous êtes toujours dans le répertoire $HOME/asws: 
    cd $HOME/asws
  • Décompressez le fichier $ASWS_HOME/public/data.tar.gz 
    tar xzf $ASWS_HOME/public/data.tar.gz
  • Décompressez le fichier $ASWS_HOME/xpath.tar.gz: 
    tar xzf $ASWS_HOME/public/xpath.tar.gz
  • La commande xqilla permet d’exécuter des expressions XPath et XQuery stockés dans des fichiers texte: 
    xqilla -i doc.xml query.xp

    évalue l’expression XPath dans le fichier query.xp sur le fichier doc.xml

  • Documentation XQilla: http://xqilla.sourceforge.net/Documentation

1.2 XPath

Exercice: Évaluez les requêtes dans le répertoire xquery sur le document data/roisdefrance.xml expliquez le résultat.

Exercice: Ecrivez les requêtes suivantes en créant un fichier par requête:

  1. les noms des fils de Catherine de Medicis; 
    <nom>Francois II</nom>
<nom>Charles IX</nom>
<nom>Henry III</nom>
  2. le nom de l’épouse de Henri II; 
    <nom>Catherine de Medicis</nom>
  3. le nom de l’époux de Mary Stuart; 
    <nom>Francois II</nom>
  4. le nom de l’époux d’Elisabeth d’Autriche; 
    <nom>Charles IX</nom>
  5. le nom de la belle mère de Mary Stuart (de la personne qui a un fils dont l’épouse s’appelle Mary Stuart); 
    <nom>Catherine de Medicis</nom>
  6. les noms des frères de Francois II; 
    <nom>Charles IX</nom>
<nom>Henry III</nom>
  7. les rois sans épouses; 
    <nom>Francois I</nom>
<nom>Henry III</nom>
  8. les noms des rois et reines avec au moins un fils; 
    <nom>Francois I</nom>
<nom>Catherine de Medicis</nom>
  9. les noms des rois et reines sans fils; 
    <nom>Henri II</nom>
<nom>Francois II</nom>
<nom>Mary Stuart</nom>
<nom>Charles IX</nom>
<nom>Elisabeth d Autriche</nom>
<nom>Henry III</nom>

Exercice: (optionnel) Essayez de réécrire les requêtes précédentes en remplaçant le document data/roisdefrance.xml par le document data/roisdefranceplat.xml

1.3 XQuery (optionnel)

Exercice: répondez aux questions précédentes en utilisant XQuery avec XBase

2 TP – Manipulation RDF avec Jena

2.1 Préparation

  • Mise-à-jour de l’environnement Linux: 
    source /Infos/bd/dm/asws/public/config
  • Décompressez le fichier $ASWS_HOME/public/data.tar.gz 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/data.tar.gz

2.2 Transformation RDF

Les commandes rapper et riot permettent de transformer des fichiers RDF d’un format à un autre:

riot -help
  • N3: format N3/Turtle (extension .ttl)
  • N-TRIPLE: format triplets (extension .nt)
  • RDF/XML: format XML étendu (extension .rdf)
  • RDF/XML-ABBREV: format XML étendu (extension .xml)

Exemples:

riot -out=N3 fichier.xml
rapper -help

formats input:

  • rdfxml RDF/XML (default)
  • ntriples N-Triples
  • turtle Turtle Terse RDF Triple Language
  • trig TriG – Turtle with Named Graphs
  • rss-tag-soup RSS Tag Soup
  • grddl Gleaning Resource Descriptions from Dialects of Languages
  • guess Pick the parser to use using content type and URI
  • rdfa RDF/A via librdfa
  • json RDF/JSON (either Triples or Resource-Centric)
  • nquads N-Quads

formats output:

  • ntriples N-Triples (default)
  • turtle Turtle Terse RDF Triple Language
  • rdfxml-xmp RDF/XML (XMP Profile)
  • rdfxml-abbrev RDF/XML (Abbreviated)
  • rdfxml RDF/XML
  • rss-1.0 RSS 1.0
  • atom Atom 1.0
  • dot GraphViz DOT format
  • json-triples RDF/JSON Triples
  • json RDF/JSON Resource-Centric
  • html HTML Table
  • nquads N-Quads

Exemples:

rapper -i rdfxml -o turtle data/rois.xml > data/rois.ttl

Cette commande permet en particulier de transformer un fichier RDF en graphe dans le format dot pour la visualisation (voir section ci-dessous).

  • Transformation d’un graphe RDF (Turtle) en format SVG: 
    mkdir $HOME/asws/gendata
cd $HOME/asws
rapper -i rdfxml -o dot data/rois.xml  | dot -Tsvg > gendata/rois.svg
  • Visualisation avec firefox : 
    firefox gendata/rois.svg

2.3 Exercices

Exercice: Transformez les deux documents data/roisgraphe.xml et data/roisarbre.xml dans différents formats et comparez les documents générés dans un répertoire gendata:

mkdir $HOME/asws/gendata
cd $HOME/asws
rapper -o turtle data/roisgraphe.xml > gendata/roisgraphe.ttl
less gendata/roisgraphe.ttl
rapper -o turtle data/roisarbre.xml > gendata/roisarbre.ttl
less gendata/roisarbre.ttl

Exercice: Est-ce que les deux documents représentent le même graphe RDF ?

Exercice: Transformez les trois documents data/rois.rdf, data/rois2.rdf et data/rois3.rdf en format N3/Turtle et en N-TRIPLE et comparez les résultats.

Exercice: Combien de noeuds blancs il y a dans chacun des trois graphes ?

Exercice: Affichez les graphes data/roisgraphe.xml et data/roisarbre.xml

2.4 Stockage RDF

Jena fournit un système de stockage pour des données RDF appelé Jena TDB1. Les commandes disponibles sont:

  • Créer (si nécessaire) un base de données et charger un fichier (de préférence en format Turtle): 
    tdbloader --loc=<db> <fichier>
  • Afficher le contenu d’une base de données: 
    tdbdump --loc=<db>
  • Afficher des statistiques (voir TP optimisation, section [sec:tdbstats]): 
    tdbstats --loc=<db>
  • Effacer la base de données: 
    rm -rf <db>

Exercice: Créez une base RDF db/rois.tdb et chargez les graphes data/rois.rdf et data/rois_schema.rdfs:

mkdir $HOME/asws/db
mkdir $HOME/asws/gendata
cd $HOME/asws
rapper -o turtle data/rois.rdf > gendata/rois.ttl
rapper -o turtle data/rois_schema.rdfs > gendata/rois_schema.ttl
tdbloader --loc=db/rois.tdb gendata/rois.ttl gendata/rois_schema.ttl

Exercice: Afficher le contenu et les statistiques du (des) graphe(s) RDF dans db/rois.tdb. Combien de triples, de reines (ressources de type Reine) et de rois (ressources de type Roi) sont dans la base ?

Exercice: Rechargez les deux fichiers data/rois.rdf et data/rois_schema.rdfs une deuxième fois et affichez les statistiques. Qu’est-ce que vous observez ?

Exercice: Créez une base RDF db/rois2.tdb et chargez le graphes data/rois2.rdf

Exercice: Affichez le contenu et les statistiques de db/rois2.tdb. Combien de noeuds blancs il y a dans db/rois2.tdb ?

Exercice: Rechargez le fichier data/rois2.rdf une deuxième fois et affichez les statistiques. Pourquoi le nombre de triplets augmente à chaque fois qu’on charge le fichier à nouveau?

2.5 Inférence RDF/S

La commande infer permet de matérialiser la transitivité des propriétés subClassOf et subPropertyOf dans un schéma RDFS:

infer --rdfs=<schéma> <graphe>

Exercice: Générer un fichier gendata/rois_infer.nt (triplet) qui matérialise les propriétés subClassOf et subPropertyOf définies dans le schéma data/rois_schema.ttl dans le graphe data/rois.ttl

Exercice: Visualisez le graphe généré.

rapper -i ntriples -o dot gendata/rois_infer.nt | dot -Tsvg > gendata/rois_infer.svg
firefox gendata/rois_infer.svg

Exercice: Chargez le nouveau graphe gendata/rois_infer.nt et le schéma gendata/rois_schema.ttl dans la base db/rois_infer.tdb.

Exercice: Analysez les statistiques (nombre de classes, propriétés, instances, …).

Exercice: Visualisez le contenu de la base db/rois_infer.tbd.

tdbdump --loc=db/rois_infer.tdb > gendata/rois_infer_dump.nt
rapper -i ntriples -o dot  gendata/rois_dump.nt | dot -Tsvg > gendata/rois_infer_dump.svg
firefox gendata/rois_infer_dump.svg

3 TP – SPARQL

3.1 Préparation

  • Mise-à-jour de l’environnement Linux: 
    source /Infos/bd/dm/asws/public/config
  • Décompressez le fichier $ASWS_HOME/public/data.tar.gz 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/data.tar.gz
  • Décompressez le fichier $ASWS_HOME/public/queries.tar.gz 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/sparql.tar.gz

3.2 Interrogation SPARQL

La commande sparql permet d’évaluer des requêtes SPARQL:

sparql --data=<fichier.rdf> --query=<fichier.sparql>
  • <fichier.rdf> indique le fichier interrogé
  • <fichier.sparql> contient la requête SPARQL à exécuter.

3.3 Interrogation d’un seul graphe

Exercice: Affichez et évaluez la requête sparql/file/rois/q1.sparql sur le document data/roisdbpedia.ttl.

cat sparql/file/rois/q1.sparql
sparql --data=data/roisdbpedia.ttl --query=sparql/file/rois/q1.sparql

Exercice: Définissez et évaluez les requêtes SPARQL suivantes sur le graphe RDF data/roisdbpedia.ttl:

  1. Les noms des rois avec leur date de naissance.
  2. Les noms des rois avec leur date de naissance (optionnel)
  3. Les noms des reines avec les noms des époux.
  4. Les noms des reines qui sont nées la même année que leurs époux avec les noms de leurs époux (il faut utiliser la fonction year).
  5. Les noms des rois sans fils (deux solutions).
  6. Expliquez le résultat de la requête suivante: 
    PREFIX asws: <http://www.asws.com/rois#>
PREFIX rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?n
WHERE { { ?a asws:nom ?n } MINUS { ?b asws:fils ?f } }

Exercice: Interrogation de schéma RDFS: définissez et évaluez les requêtes SPARQL suivantes sur le schéma RDFS data/rois_schema.ttl:

  • Toutes les propriétés du schéma.
  • Toutes les classes et leurs sous-classes.

3.4 Interrogation de plusieurs graphes

Exercice: Expliquez la réponse de la requête sparql/file/rois/q1a.sparql.

cat sparql/file/rois/q1a.sparql
sparql --base=$HOME/asws/ --query=sparql/file/rois/q1a.sparql

Exercice: Expliquez la réponse de la requête sparql/file/rois/q1anamed.sparql.

cat sparql/file/rois/q1a.sparql
sparql --base=$HOME/asws/ --query=sparql/file/rois/q1anamed.sparql

Exercice: Définissez et évaluez les requêtes SPARQL suivantes sur le graphe RDF data/roisdbpedia.ttl et le schéma RDFS data/rois_schema.ttl:

  • Toutes les instances des sous-classes de la classe asws:Homme.
  • Tous les triplets (?a ?p ?b) qui relient une ressource ?a du graphe data/roisdbpedia.ttl à une ressource ?b du graphe data/rois_schema.ttl (graphes nommés).

3.5 Expressions de chemins

Exercice: Définissez et évaluez les requêtes SPARQL suivantes sur les graphes RDF data/roisdbpedia.ttl et data/succdbpedia.ttl:

  • Tous les successeurs directes et indirectes de Louis XVI.
  • Les noms de toutes les instances de sous-classes directes et indirectes de la classe asws:Personne.
  • Les noms des personnes et de leurs conjoints.
  • Les noms des personnes et de leurs enfants.
  • Les noms des personnes et de leurs descendants.

3.6 Requêtes d’aggrégation

  • Le nombre de successeurs par roi ou reine.
  • Le nombre d’enfants par roi ou reine.
  • Le nombre d’époux par reine.
  • Le nombre de roi de reines par dynastie.
  • Le nombre de descendants et d’ancêtres par roi ou reine.

4 TP – Règles RDF

4.1 Préparation

  • Mise-à-jour de l’environnement Linux: 
    source /Infos/bd/dm/asws/public/config
  • Décompressez le fichier $ASWS_HOME/public/data.tar.gz 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/data.tar.gz
  • Décompressez le fichier $ASWS_HOME/public/rules.tar.gz 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/rules.tar.gz

4.2 Règles d’inférence

La commande java jena.RuleMap permet d’appliquer des règles d’inférence à des graphes RDF

java jena.RuleMap -il <inlang> -ol <outlang> [-d>] rulefile infile
  • <inlang> indique le format d’entrée (N3 par défaut)
  • <outlang> indique le format de sortie (N3 par défaut)
  • -d indique que la commande doit uniquement retourner les données déduites.

Exercice: Appliquez les règles rules/rois.rules au document data/rois6.ttl et vérifiez le résultat obtenu.

java jena.RuleMap -ol N3 rules/rois.rules data/rois6.ttl \
   > gendata/rois6_rules.ttl
visualize turtle gendata/rois6_rules.ttl ./gendata/rois6_rules.svg

Exercice: Copiez le fichier rules/rois.rules dans un nouveau fichier rules/rois2.rules Exercice: Ajoutez des règles suivantes au fichier: rules/rois2.rules:

  1. si x est le :conjoint de y et x est une :Femme alors x est l’:épouse de y.
  2. [r2] la propriété :époux est l’inverse de la propriété :épouse.
  3. si x est l’:épouse de y alors x est une :Femme et y est un :Homme.
  4. un :Homme qui est un :enfant de x est un :fils de x (propriété)
  5. une :Femme qui est un :enfant de x est une :fille de x (propriété)
  6. la :fille d’un :Roi ou d’une :Reine est une :Princesse.
  7. le :fils d’un :Roi ou d’une :Reine est un :Prince.
  8. un :enfant d’un :enfant de x est un :petit_enfant de x (propriété)
  9. si x est l’:enfant de y et y est un :Homme alors y est le :père de x.
  10. si x est l’:enfant de y et y est une :Femme alors y est le :mère de x.

Exercice: Appliquez les règles rules/rois2.rules au document data/rois6.ttl et vérifiez le résultat dans gendata/rois6_rules2.ttl:

java jena.RuleMap -ol N3 rules/rois2.rules data/rois6.ttl \
       > gendata/rois6_rules2.ttl
  • Pourquoi Catherine de Medicis n’est pas reconnue comme épouse de Henri III?

Exercice: Créez un document triplets gendata/rois6_infer.nt qui matérialise dans le document data/rois6ttl les propriétés rdfs:subClassOf et rdfs:subPropertyOf du schéma RDFS data/rois_schema.ttl en utilisant la commande infer (voir TP 2).

infer --rdfs=data/rois_schema.ttl data/rois6.ttl \
       > gendata/rois6_infer.nt

Exercice: Concaténez les deux fichiers gendata/rois_schema.ttl et gendata/rois6_infer.nt pour créer un seul fichier Turtle gendata/rois6_all.ttl en utilisant la commande riot (section [sec:transformation]:

Exercice: Appliquez à nouveaux les règles rules/rois2.rules à nouveau au document gendata/rois6_all.ttl pour générer un nouveau document gendata/rois6_all_rules2.ttl. Qu’est-ce que vous observez et donnez une explication ?

java jena.RuleMap -ol N3 rules/rois2.rules gendata/rois6_all.ttl \
      > gendata/rois6_all_rules2.ttl

Exercice: Ajoutez une règle qui définit la relation de descendant et appliquez à nouveaux les règles rules/rois2.rules.

Exercice: On observe que certaines propriétés comme :enfant, :petit_enfant, :fille, :fils, :époux, :epouse, :conjoint ont comme valeurs des littéraux (le nom des personnes au lieu des ressources). Écrivez des règles rules4.rules qui replacent ces littéraux par des noeuds blancs qui ont une propriété :nom avec le littéral comme valeur. Appliquez ces règles au document ./gendata/rois6_all.ttl et vérifiez le résultat. Remarque: utilisez les fonctions isLiteral et makeSkolem définies dans https://jena.apache.org/documentation/inference/#RULEbuiltins.

Exercice: Ajoutez à toutes les ressources qui ont une propriété :enfant, :fille, :fils, :époux, :epouse, :conjoint, :père, :mère ou :descendant une propriété :nom qui contient l’identifiant local (sans préfixe) de la ressource comme valeur. Il faut utiliser les fonctions strConcat, regex et noValue (pour vérifier s’ils ont déjà un nom).

Exercice: Ajoutez une règle qui remplace tous les caractère ’_’ par un espace ’ ’ dans les noms de personnes (utilisez la fonction regex et strConcat).

Exercice: Écrivez des règles rules3.rules qui enlèvent

  • les triplets (apb) s’il existe une sous-propriété q de p et un triplet (apb). Par exemple, on enlève les propriétés :enfant entre deux personnes qui sont déjà reliées par la propriété :fils ou :fille (utilisez la fonction drop).
  • les triplets (ardf : typex) s’il existe une sous-classe y de x et un triplet (ardf : typey). Par exemple, on enlève les (ardf : typeFemme) pour les reines (utilisez la fonction drop).

Appliquez ces règles au graphe ./gendata/rois6_all.ttl:

{}
 java jena.RuleMap -ol N3 rules/rois3.rules gendata/rois6_all_rules2.ttl \
     > gendata/rois6_all_rules2_3.ttl

5 TP – OWL/Jena: Interrogation sémantique

5.1 Préparation

  • Mise-à-jour de l’environnement Linux: 
    source /Infos/bd/dm/asws/public/config
  • Décompressez les fichiers $ASWS_HOME/public/owl.tar.gz et 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/owl.tar.gz
  • Compilez le programme roisOwl.java: 
    cd owl
mkdir gendata
cp data/* gendata
javac owlsparql.java
  • Le programme owlsparql permet d’exécuter des requêtes SPARQL sur des graphes RDF (ABOX) avec une ontology OWL (TBOX): 
    usage: java owlsparql
 -d,--data <arg>     data file path
 -f,--format <arg>   output format (optional): TURTLE (default) NT JSON-LD
                     RDF/XML-ABBREV
 -n,--newfacts       produce only new facts
 -o,--owl <arg>      OWL ontology file path (optional)
 -q,--query <arg>    SPARQL query file path (optional)

5.2 Exercice

Exercice: Appliquez le programme owlsparql pour comprendre son fonctionnement:

  1. afficher le contenu du document data/monarques_data.ttl: 
    java  owlsparql -d data/monarques_data.ttl
  2. interroger document data/monarques_data.ttl avec la requêtesparql/personnes.sparql. 
    java  owlsparql -d data/monarques_data.ttl -q sparql/personnes.sparql -f nt

    Pourquoi la réponse est vide ?

  3. interroger document data/monarques_data.ttl avec la requête sparql/personnes.sparql après l’application du fichier OWL data/monarques_onto.ttl. 
    java  owlsparql -d data/monarques_data.ttl -o data/monarques_onto.ttl \
-q sparql/personnes.sparql

    Pourquoi le réponse n’est plus vide?

Exercice: Exécutez les commandes ci-dessous et expliquez ce qui se passe:

  1. évaluez les deux requêtes suivante: 
    java owlsparql -d data/monarques_data.ttl -o gendata/monarques_onto.ttl \
-q sparql/monarques_sans.sparql
java owlsparql -d data/monarques_data.ttl -o gendata/monarques_onto.ttl \
-q sparql/monarques.sparql

    Pourquoi les deux requêtes ne retournent pas le même résultat ?

  2. modifiez gendata/monarques_onto.ttl en ajoutant l’expression OWL suivante: 
      :Monarque owl:unionOf (:MonarqueAnglais :MonarqueFrancais ) .
  3. Réévaluez les requêtes précédentes. Pourquoi le résultat est le même maintenant ?

Exercice: Évaluez d’abord la requête <requete>_sans.sparql et modifiez ensuite le fichier gendata/monarques_onto.ttl pour que la requête <requete>.sparql retourne le même résultat.

  1. sparql/monarques.sparql
  2. sparql/enfants.sparql
  3. sparql/descendants.sparql
  4. sparql/ancetres.sparql
  5. sparql/successeurs.sparql
  6. sparql/dynastiesfrancaises.sparql
  7. sparql/dynastiesanglaises.sparql
  8. sparql/avecsuccesseur.sparql
  9. sparql/rois.sparql
  10. sparql/reines.sparql
  11. sparql/enfantsroyal.sparql
  12. sparql/princesses.sparql
  13. sparql/princes.sparql

Exercice: Ajoutez les contraintes suivante et vérifiez les avec la commande suivante (testez chaque contrainte individuellement pour gagner du temps):

{}
java owlsparql -d data/monarques_data.ttl  -o gendata/monarques_onto.ttl
  1. une personne ne peut pas être roi et reine en même temps.
  2. une personne ne peut pas être un monarque français et un monarque anglais en même temps.
  3. les dynasties anglaises et françaises sont séparées.
  4. un monarque ne peut pas avoir deux successeurs.

Exercice: Traduisez les contraintes ci-dessus en requêtes SPARQL (ask) qui retournent FALSE quand la contrainte est satisfaite et TRUE sinon.

Exercice: Exécutez la requête sparql/ancetres.sparql:

java owlsparql -d data/monarques_data.ttl -o gendata/monarques_onto.ttl \
-q sparql/ancetres.sparql

Qu’est-ce que vous observez ?

6 TP – SPARQL et Optimisation / Yago / DBpedia

6.1 Préparation

  1. Mise-à-jour de l’environnement Linux: 
    source /Infos/bd/dm/asws/public/config
  2. Décompressez le fichier $ASWS_HOME/public/sparql.tar.gz 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/sparql.tar.gz
  3. Copiez la base yago.tdb: 
    export YAGO_DB=/tmp/yago.tdb
tdbloader --loc=$YAGO_DB $ASWS_HOME/yago/yagoFacts.ttl
tdbloader --loc=$YAGO_DB $ASWS_HOME/yago/yagoSimpleTypes.ttl
tdbloader --loc=$YAGO_DB $ASWS_HOME/yago/yagoSimpleTaxonomy.ttl
tdbloader --loc=$YAGO_DB $ASWS_HOME/yago/yago_classes.ttl
tdbloader --loc=$YAGO_DB $ASWS_HOME/yago/yago_subclasses.ttl
touch $YAGO_DB/none.opt

6.2 Commandes

Génération de statistiques sur une base TDB

tdbstats --loc=DIR [--graph=URI]
  • DIR indique l’entrepôt RDF ($YAGO_DB)
  • URI indique l’URI d’un graphe dans l’entrepôt

Les statistiques sont décrites sous forme de motifs

((subj pred obj) count)

où

  • subj, pred et obj peuvent prendre la valeur VAR (une variable), TERM (un terme), ANY (une variable ou un terme) ou indiquer une URI;
  • count indique le nombre d’occurrences.

Par exemple:

  • ((TERM TERM TERM) 1) indique que chaque triplet a une occurrence.
  • ((TERM p:prop VAR) 1) indique que la propriété p:prop est une propriété fonctionnelle

Le motif (predicate count) est un raccourci pour:

((TERM predicate ANY) X)
((ANY predicate TERM) Y)
((ANY predicate ANY) count)

où X et Y dépendent de la taille du graphe. Voir https://jena.apache.org/documentation/tdb/optimizer.html pour plus de détails.

Interrogation d’une base TDB

tdbquery [--time] [--debug] [--explain] --loc=DIR  --query=<FILE>
  • –time (optionnel) retourne le temps d’exécution de la requête
  • –debug (optionnel) affiche le plan d’exécution de la requête
  • –explain (optionnel) affiche le plan d’exécution de la requête plus d’autres informations (voir partie optimisation)
  • DIR indique l’entrepôt RDF ($YAGO_DB)
  • FILE indique le fichier avec la requête SPARQL

6.3 Interrogation d’une base TDB

Exercice: Affichez et évaluez la requête sparql/tdb/yago/q1.sparql.

Exercice: Affichez et évaluez les deux requêtes SPARQL suivantes sur la base yago.tdb et comparez les performances en utilisant l’option –time (vous pouvez arrêter l’évaluation d’une requête avec CTL-C):

tdbquery --time --loc=$YAGO_DB --query=<requête>
  1. sparql/tdb/yago/q2a.sparql
  2. sparql/tdb/yago/q2b.sparql

Qu’est-ce que vous observez ?

Exercice: Affichez et évaluez les deux requêtes SPARQL précédentes sur la base yago.tdb et comparez les plans d’exécution et le temps d’exécution en utilisant les options –debug et –time:

tdbquery --time --debug --loc=$YAGO_DB --query=<requête>

Qu’est-ce que vous observez ?

Exercice: Affichez et évaluez les trois requêtes SPARQL suivantes sur la base yago.tdb et comparez les plans d’exécution et le temps d’exécution (vous pouvez arrêter l’évaluation d’une requête avec CTL-C):

  1. sparql/tdb/yago/q3a.sparql
  2. sparql/tdb/yago/q3b.sparql
  3. sparql/tdb/yago/q3c.sparql
  4. sparql/tdb/yago/q4a.sparql
  5. sparql/tdb/yago/q4b.sparql
  6. sparql/tdb/yago/q5a.sparql
  7. sparql/tdb/yago/q5b.sparql

Qu’est-ce que vous observez ?

6.4 Optimisation de requêtes

TDB Optimizer est un outil d’optimisation de requêtes (https://jena.apache.org/documentation/tdb/optimizer.html) avec trois stratégies d’optimisation. La stratégie est choisie par la présence d’un fichier dans le répertoire de l’entrepôt RDF;

  • none.opt ne modifie pas le plan d’origine et exécute les motifs de triplets dans l’ordre de la requête
  • fixed.opt réordonne les motifs de triples par le nombre de variables dans le motif
  • stats.opt utilise des statistiques sur les données de l’entrepôt interrogé

Chaque filtre est appliqué immédiatement après l’instanciation de toutes les variables nécessaires.

Exercice: Remplacez le fichier $YAGO_DB/none.opt par un fichier (vide) $YAGO_DB/fixed.opt:

rm $YAGO_DB/*.opt
touch $YAGO_DB/fixed.opt

Exercice: Affichez et évaluez les requêtes SPARQL précédentes et comparez les performances et les plans d’exécution. Qu’est-ce que vous observez ?

Exercice: Générez et affichez les statistiques de la base /tmp/yago.tdb:

tdbstats --loc=$YAGO_DB > yago.stats
less yago.stats

Exercice: Copiez les statistiques dans la base RDF:

rm $YAGO_DB/*.opt
cp yago.stats $YAGO_DB/stats.opt

Exercice: Affichez et évaluez les requêtes SPARQL précédentes et comparez les performances et les plans d’exécution. Qu’est-ce que vous observez ?

7 TP – Linked-Open-Data

7.1 Préparation

  1. Mise-à-jour de l’environnement Linux: 
    source /Infos/bd/dm/asws/public/config
  2. Décompressez les fichiers $ASWS_HOME/public/sparql.tar.gz et $ASWS_HOME/public/lod.tar.gz 
    cd $HOME/asws
tar xzf $ASWS_HOME/public/sparql.tar.gz
tar xzf $ASWS_HOME/public/lod.tar.gz
  3. Installez la librairie rdflib: 
    cd
pip install --user --upgrade pip
pip install --user rdflib
pip install --user SPARQLWrapper
cd $HOME/asws
  4. Python
  5. rdflib:
  6. SPARQLWrapper
  7. Silk Workbench est une application Web qui guide l’utilisateur tout au long du processus d’intégration différentes sources de données RDF.Silk Workbench offre les fonctionnalités suivantes:
    • Il permet à l’utilisateur de gérer différents ensembles de sources de données RDF et de définir des tâches d’intégration et de résolution d’entités.
    • La résolution d’entités étant généralement un processus itératif, Silk Workbench permet à l’utilisateur d’évaluer rapidement les liens générés par la spécification de lien en cours.
    • Il permet à l’utilisateur de créer et de modifier un ensemble de liens existants pour évaluer la spécification de lien en cours.

7.2 Interrogation de DBPedia

Dans cet exercice on interroge DBpedia en utilisant l’interface DBpediaLive : http://live.dbpedia.org/

Exercice: Connectez vous à la page http://live.dbpedia.org/sparql et évaluez les requêtes sparql/dbpedia/q1.sparql et sparql/dbpedia/q2.sparql (en utilisant le format HTML pour afficher le résultat).

Exercice: Définissez et évaluez les requêtes suivantes (affichez le résultat en format HTML):

  1. Tous les endroits habités en France (type dbpedia-ont:PopulatedPlace, propriété dbpedia-ont:country, pays dbpedia:France)
  2. Combien d’endroits habités il y a en France (enregistrés dans DBPedia) ? (37696)
  3. Toutes les propriétés de la ville que vous habitez (si elle est dans DBPedia).
  4. Toutes les capitales de l’Europe (ressources de type yago:CapitalsInEurope)
  5. Toutes les capitales de l’Europe avec leur pays si présent (propriété dbpedia-ont:country) et leur population si présent (propriété dbpprop:mayor) et leur maire si présent (propriété dbpprop:population).

7.3 Linked-Open-Data (LOD)

Dans cette exercice nous allons interroger deux portails (endpoints) SPARQL:

Exercice: Exécutez les trois programmes suivant et étudiez le code exécuté:

python lod/local_directors.py
python lod/dbpedia_lars_von_trier.py
python lod/dbpedia_lars_von_trier_graph.py
python lod/dbpedia_director.py 'Lars T'

La dernière commande écrit le résultat dans des fichiers (voir code).

Exercice: Écrivez les programmes suivants qui interrogent dbpedia pour afficher :

  1. Tous les films des metteurs en scène dans le document lod/directors.ttl avec les noms de leurs acteurs.
  2. Tous les films d’un metteur en scène (le nom est donné comme paramètre du programme).
  3. Les metteurs en scène qui apparaissent dans leurs propres films comme acteurs: nom du metteur en scène, titre du film
  4. Tous les films dans lesquels un metteur en scène apparaît: titre du film, nom du metteur en scène du film, nom du metteur en scène qui apparaît

7.4 Silk (optionnel)

Lancez Silk Workbench et ouvrez la page http://localhost:9000:

silk-workbench

Exemple:

  • Chargez l’exemple (onglet Start)
  • Ouvrez le projet movies (double-click sur movies.
  • Examinez la tache linking movies
    • les entités reliés (bouton Properties)
    • la règle de matching appliquée (bouton Open)
  • Affichez les liens owl:sameAs générés par les règles (onglets Generate Links/Start)
  • Affichez les liens référence (onglet Reference Links) positifs, negatifs et non-étiquetés (Positive/Negative/Unlabeled).
  • Triez les règles par leurs scores (ascendant)
  • Examinez le détails des liens (bouton Expand All) par rapport aux scores obtenus.
  • Augmentez et diminuez les bornes (Treshold) dans compareTitle et compareReleaseDates et vérifiez les nouveaux liens générés ou effacés.

Exercice: Nettoyage du graphe Rois:

  • Créez un nouveau projet rois (onglet Workspace)
  • Chargez la ressource data/roisdbpedia.nt (onglet Resources)
  • Ajoutez le prefix asws:http://www.asws.com/rois# (bouton Prefixes)
  • Créez un nouveau dataset rois à partir de la ressource chargée (onglet Dataset / RDF Dump)
  • Examinez le contenu du dataset rois : Bouton Open et Onglet Sparql
  • Ajoutez le type: asws:Personne et owl:Thing à toutes les ressources du dataset rois (onglet Transform):
    • Ajoutez une tache add_personne (avec le dataset rois comme source et output)
    • Ouvrez la tache add_personne
    • Onglets Add Type Mapping, Evaluate et Execute
  • Définissez et testez une règle de matching qui créé des liens owl:sameAs entre toutes les ressources désignant la même entité.
  1. http://jena.apache.org/documentation/tdb/↩