Exploiter RDF a ec ena

Transcription

5
Exploiter RDF avec Jena
O.Curé [255 ]
JENA : Présentation
Plateforme Java pour le Web
sémantique
Open-source
Développé par un laboratoire de
Hewlett-Packard
O.Curé [256 ]
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é [257 ]
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é [258 ]
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é [259 ]
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é [260 ]
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é [261 ]
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é [262 ]
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é [263 ]
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é [264 ]
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é [265 ]
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é [266
}
]
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é [267 ]
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é [268 ]
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é
[269 ]
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é [270 ]
"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é [271 ]
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
Insensible à
la casse
dominique parent de baptiste
O.Curé [272 ]
RDQL :programmation
Java
Mode de fonctionnement :
Query qr1 = new Query("SELECT *
WHERE (?s,?p,?o)");
On passe la requête à un
qr1.setSource(model);
objet instancié de la classe QueryEngine qe = new
Query.
QueryEngine(qr1);
QueryResults results = qe.exec();
On passe alors l'objet à un
for(it=results; it.hasNext();) {
objet du type
ResultBinding res =
QueryEngine.
(ResultBinding)it.next() ;

Les résultats se trouvent
dans un objet du type
QueryResults

On accède aux résultats
via la classe ResultBinding
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é [273 ]
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é [274 ]
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);
Idem pour intersection et difference
O.Curé [275 ]
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é [276 ]
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é [277 ]
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é [278 ]
SPARQL
O.Curé [279 ]
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é [280 ]
Patterns
Variables are prefixed with a '?' or '$'
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é [281 ]
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é [282 ]
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/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?name
WHERE { ?person foaf:mbox
<mailto:[email protected]> .
?person foaf:name ?name . }
name
----------"Alice"
O.Curé [283 ]
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é [284 ]
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é [285 ]
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é [286 ]
Syntax for literals
General syntix is string (enclosed with
or '') with an optional tag for
language introduced by @

web or web@en, not the same thing
when querying.
No for integers
O.Curé [287 ]
Blank nodes in query
results
Query results can contain blank nodes.
They are written in the form _:
followed by a blank node label
O.Curé [288 ]
CONSTRUCT
The select query form is not the only
available form in SPARQL.
The CONSTRUCT query form returns an
RDF graph constructed by substituting
variables in a set of triple templates.
The graph is built based on a template
which is used to generate RDF triples
based on the results of matching the
graph pattern of the query.
O.Curé [289 ]
CONSTRUCT (2)
prefix org:
<http://example.com/ns#>
_:a org:employeeName "Alice" .
_:a org:employeeId
12345 .
_:b org:employeeName "Bob" .
_:b org:employeeId
67890 .
PREFIX org: <http://example.com/ns#>
CONSTRUCT { ?x foaf:name ?name }
WHERE { ?x org:employeeName ?name }
O.Curé [290 ]
CONSTRUCT (3)
prefix org: <http://example.com/ns#> .
_:x foaf:name "Alice" .
_:y foaf:name "Bob" .
O.Curé [291 ]
ASK
The ASK query form returns a boolean
indicating whether a query pattern
matches or not.
ASK { ?x foaf:name "Alice" }
O.Curé [292 ]
Solution sequence
modifiers
Order modifier: put the solutions in order
Projection modifier: choose certain variables
Distinct modifier: ensure solutions in the
sequence are unique
Reduced modifier: permit elimination of some
non-unique solutions
Offset modifier: control where the solutions start
from in the overall sequence of solutions
Limit modifier: restrict the number of solutions
O.Curé [293 ]
Solution sequence
modifiers - ORDER
PREFIX foaf:
SELECT ?name
ORDER BY ?name
We can use ASC and DESC like in SQL :
ORDER BY DESC (?name)
O.Curé [294 ]
Solution sequence
modifiers - Projection
PREFIX foaf:
SELECT ?name
Only a subset of the variables of the query is presented
in the result
O.Curé [295 ]
Solution sequence
modifiers - Duplicates
Duplicates can be eliminated from the result set
PREFIX foaf:
SELECT DISTINCT ?name
O.Curé [296 ]
Solution sequence modifiers
OFFSET and LIMIT
PREFIX foaf:
SELECT DISTINCT ?name
LIMIT 5
OFFSET 10
OFFSET causes the solutions generated to start after the
specified number of solutions. An OFFSET of zero has no
effect.
The LIMIT clause puts an upper bound on the number of
solutions returned. If the number of actual solutions is
greater than the limit, then at most the limit number of
solutions will be returned.
O.Curé [297 ]
More about SPARQL
Not a W3C recommandation yet
Read:

SPARQL Query Language for RDF

SPARQL Protocol for RDF

SPARQL Query Results XML Format
Also a SPARQL tutorial on the Jena site
O.Curé [298 ]
SPARQL with Jena
Model model = ModelFactory.createDefaultModel();
model.read("file:/home/olive/projets/dalton/metadata2.rdf");
String queryStr1 = "SELECT ?x WHERE {?x <http://www.univmlv.fr/~ocure/ontologies/loc1Med.owl#hasATC> \"D06AX01\"}";
//"SELECT ?att WHERE {?att <http://www.univmlv.fr/~ocure/mapping.owl#mappedToConcept> <http://www.univmlv.fr/~ocure/ontologies/loc2Med.owl#AntibioMedPrescription>}"
;
Query query1 = QueryFactory.create(queryStr1) ;
QueryExecution qexec =
QueryExecutionFactory.create(query1, model) ;
O.Curé [299 ]
SPARQL with Jena (2)
try {
ResultSet results = qexec.execSelect() ;
for ( ; results.hasNext() ; )
{
QuerySolution soln = results.nextSolution() ;
RDFNode x = soln.get("?x") ;
// Get a result
variable by name.
System.out.println("obj= "+x);
}
} finally { qexec.close() ; }
O.Curé [300 ]
SPARQL endpoint
A SPARQL endpoint is a conformant
SPARQL protocol service as defined in
the SPROT specification. A SPARQL
endpoint enables users (human or
other) to query a knowledge base via
the SPARQL language.
O.Curé [301 ]
SPARQL endpoint / Jena
Querying a SPARQL endpoint with a Java
program using the Jena framework
String prefixes="PREFIX foaf:
<http://xmlns.com/foaf/0.1/>";
String queryStr1 = prefixes + "SELECT ?y WHERE
{?y foaf:name \"Dan Suciu\"} LIMIT 10";
Query query1 = QueryFactory.create(queryStr1) ;
QueryExecution qexec =
QueryExecutionFactory.sparqlService("http://ww
w4.wiwiss.fu-berlin.de/dblp/sparql", query1);
O.Curé [302 ]
6
OWL
Web Ontology Language
O.Curé [303 ]
OWL
Une recommendation du W3C pour représenter
des ontologies pour le Web Sémantique.
Influences : RDF, DL et les frames
OWL est un langage pour structurer l'information
dans des ontologies : définir les concepts d'un
domaine et les relations liant ces concepts.
OWL permet également de définir les instances.
O.Curé [304 ]
OWL
OWL possède 3 sous-langages : OWL Lite, OWL
DL and OWL Full
OWL propose plusieurs syntaxes : RDF,
OWL/RDF, abstract syntax.
Termes utilisés avec OWL :

Concepts = classes

Rôles = propriétés
O.Curé [305 ]
Influences de OWL
O.Curé [306 ]
OWL comme une DL
O.Curé [307 ]
Syntaxe
OWL/RDF syntax
<owl:Class rdf:ID="Cat">
<rdfs:subClassOf rdf:resource="#Animal"/>
</owl:Class>
Abstract syntax
Class (a:Cat partial a:Animal)
O.Curé [308 ]
OWL Lite
OWL Lite ressemble aux Frames : supporte la
classification hiérarchique des classes et propriétés,
des contraintes simples
OWL Lite possède moins de constructeurs que OWL
DL

Descriptions dans des descriptions

Unions, OneOf, etc..
OWL Lite correspond à DL SHIN(Dn)

Qui est décidable

Avec des implémentations efficaces.
O.Curé [309 ]
OWL DL
Expressivité riche en gardant la
complétude computationelle et la
décidabilité.
Ne permet pas toute la liberté
syntaxique de RDF :

Ex : une classe ne peut être une propriété
ou une instance, une propriété ne peut
être une classe ou une instance.
Correspondence avec la DL SHOIN(D)
O.Curé [310 ]
OWL DL (2)
40 primitives : 16 pour les classes et 24
pour les propriétés.
Classes pour définir des classes et des
restrictions :

owl:Class = spécialisation de rdfs:Class

owl:Restriction = spécialisation de
owl:Class pour définir des restrictions sur
des classes (existencielle, universelle,
number restrictions), etc.).
O.Curé [311 ]
Eléments du langage
Classes pour définir des propriétés :

owl:ObjectProperty, owl:DatatypeProperty,
owl:TransitiveProperty,
owl:SymmetricProperty,
owl:FunctionalProperty,
owl:InverseFunctionalProperty (une sous
classe de ObjectProperty pour OWL Lite et
DL, également une sous-classe de
datatype Property pour OWL Full) sont des
spécialisations de rdf:Property
O.Curé [312 ]
Eléments du langage (2)
Classes pour déclarer l'inégalité entre
individus :

owl:AllDifferent pour spécifier que des
individus sont différents.

Nécessaire car OWL ne suppose pas UNA

Donc 2 définitions d'individus avec des
identifiants différents peuvent
correspondre au même individu.
O.Curé [313 ]
Classes pour l'énumération de types de données
:

owl:DataRange pour énumérer des données
avec des valeurs prédéfinies.
Classes prédéfinies : owl:Thing et owl:Nothing
Classes pour la description d'ontologie :
owl:Ontology
Version des ontologies : owl:DeprecatedClass,
owl:DeprecatedProperty
O.Curé [314 ]
Propriétés pour définir des classes dans OWL
Lite :

owl:intersectionOf : le codomaine est restreint
aux identifiants de classes et restrictions sur
les propriétés.

Restriction :
owl:AllValuesFrom
owl:SomeValuesFrom
owl:cardinality, owl:minCardinality,
owl:maxCardinality avec des valeurs de 0
ou 1.
O.Curé [315 ]
Propriétés pour définir des classes dans OWL DL:

owl:intersectionOf, owl:unionOf,
owl:complementOf (négation) sont sans
restriction sur le codomaine.

owl:OneOf pour définir des collections
d'individus
Restrictions :

Entier naturel pour les cardinalités

owl:hasValue
O.Curé [316 ]
Pour OWL Lite :

owl:inverseOf pour définir l'inverse d'une
propriété

owl:sameAs, owl:equivalentClass,
owl:equivalentProperty,
owl:sameIndividualAs pour définir des
équivalences entre des ressources, des
classes, des propriétés et des individus.

owl:differentFrom pour définir que 2
individus sont différents
O.Curé [317 ]
Pour OWL Lite :

owl:distinctMembers. A utiliser avec
owl:AllDifferent pour définir une liste
d'instances où les éléments sont différents
les uns des autres.
Pour OWL DL :

owl:disjointWith pour définir que des
classes sont disjointes.
O.Curé [318 ]
O.Curé [319 ]
OWL Full
Très expressif (méta-classes, classes
comme valeur d'object property).
Profite de toute la liberté syntaxique de
RDF

Une classe peut être traitée comme un
ensemble d'individus et comme une
classe.
Pas d'algo efficace pour le
raisonnement.
O.Curé [320 ]
Defining n-ary relations
Problem: how to represent n-ary
relations in RDF/OWL
2 different patterns :

introduce a new class for a relation

using lists of arguments in a relation.
O.Curé [321 ]
New class for a relation
For example :
O.Curé [322 ]
New class for a relation
This approach is useful in the case of

additional attributes describing a relation

different aspects of the same relation

n -ary relation with no distinguished
participants, e.g. someone buys in a
particular book, in a shop, at a given price
for a specific purpose.
O.Curé [323 ]
Lists for arguments of a
relation
Caution : using the rdf:List vocabulary
in OWL would have put the ontology in
OWL Full.
O.Curé [324 ]
Lists for arguments of a
relation (2)
The following ontology is in OWL Lite:
O.Curé [325 ]
Outils pour concevoir des
ontologies
Open-source :

KAON , OilEd, OntoEdit, Ontolingua,
OntoSaurus, Protégé, WebODE, WebOnto
O.Curé [326 ]
Protégé
O.Curé [327 ]
Introduction
Un éditeur d'ontologies et de bases de
connaissances
Open-source
Disponible à l'URL :
http://www-protege.stanford.edu/
Développé à l'Université de Stanford en
Java
Supporte de nombreux plug-ins.
O.Curé [328 ]
Historique
Début des années 90 : Protégé II

Milieu des 90s : ProtégéWin

Environnement pour l'ingénierie des connaissances
permettant de définir des modèles et de générer
des GUI. Version pour NeXTSTEP.
Version pour Windows
Fin des 90s : Protégé2000

Version Java, Open-source

Développement de plug-ins
2003 : Protégé (à partir de la version 2.0)

Support de OWL.
O.Curé [329 ]
Plateforme pour plug-ins
Communauté très active. On trouve
des plug-ins pour :

La visualisation

L'inférence

Import et export de formats (XML, RDF,
DAML+OIL, OWL, CLIPS, Topic Maps).

Conception d'IHM

etc..
O.Curé [330 ]
Notre environnement
Le plug-in OWL

Une extension de Protégé pour permettre :
le chargement, l'enregistrement de fichiers
OWL, l'édition graphique d'expressions
OWL, l'accès à des fonctionnalités liées à
l'inférence (classifier)
Racer
O.Curé [331 ]
Démonstration
Créer des classes, des propriétés, des
instances
Lancer la classification avec Racer.
Ecrire et exécuter des requêtes en
RDQL.
Visualisation de graphes
O.Curé [332 ]
Exercice
Ecrire la terminologie complète de
l'ontologie Personne :
O.Curé [333 ]
Exercice 1
Ecrire un programme Java qui va afficher les déclarations
de la base de connaissances (Personne)
Ecrire une nouvelle méthode qui va permettre d'afficher
les sous-classes de la classe Man.
Ecrire une méthode qui va permettre d'afficher toutes les
instances de la Abox.
En vous aidant des tutoriaux sur les inférences avec Jena
(que vous devriez déjà avoir étudié) et « using a DIG
reasoner with Jena » (DIG = Description Logic
Implementation Group), intégrez le raisonneur Racer dans
le programme et chargez notre base de connaissances.
O.Curé [334 ]
Exercice 1 (2)
Afficher les instances qui sont des hommes
(« Man »).
Afficher les instances qui sont des oncles (« uncle »).
Le graphe des instances (générée avec Rice) se
trouve à l'adresse :
www.univ-mlv.fr/~ocure/Ex1PersonDLInst.png). Les
données sur les oncles ne sont pas explicites.
Regarder le code OWL pour comprendre l'inférence :
définition de la classe « Uncle », des classes
associées et des instances impliquées.
Définir à l'aide de manière programmatique en Java
la classe suivante « HappyFather » définie comme un
père ayant au moins un garçon et une fille.
O.Curé [335 ]
Exercice 1 (fin)
Modifier la classe « HappyFather » et ajouter une
contrainte supplémentaire : n'a qu'un seul enfant. La
base de connaissances contient maintenant une
classe inconsistante. A l'aide du tutoriel, programmer
l'afficher des classes inconsistances.
O.Curé [336 ]