FLASH INFORMATIQUE FI



Langages de requêtes pour base de connaissances




Francis LAPIQUE


Inférence, déduction, induction

Cet article, le dernier d’une série consacré au Web sémantique, est une sensibilisation aux techniques de raisonnement sur un domaine de connaissances. Dans les articles précédents nous avons vu comment on pouvait construire sans ambiguïté un domaine de connaissances par un ensemble de concepts ou d’axiomes, une ontologie pour faire plus court, et comment l’interroger. Nous allons aborder ici un autre aspect, celui de l’inférence.
Un résumé rapide des épisodes précédents. Le Web sémantique désigne un ensemble de technologies visant à rendre le contenu des ressources du World Wide Web accessible et utilisable par les programmes et agents logiciels, grâce à un système de métadonnées formelles, utilisant notamment la famille de langages développés par le W3C.
La brique de base de cette famille, RDF et permet de représenter toute information sous forme de graphes. Il fut étendu par OWL et (Ontology Web Language) plus expressif que RDF, et destiné à la description de classes (par des constructeurs) et de types de propriétés. OWL compte trois dialectes à l’expressivité croissante. Enfin pour compléter le tableau, SPARQL (SPARQL Protocol and RDF Query Language) un langage de requête pour RDF.
Revenons au sujet de cet article par une question qu’entend-on par inférence ? L’inférence est l’opération qui consiste à admettre une proposition en raison de son lien avec une proposition préalable tenue pour vraie. C’est un terme général dont les mots raisonnement, déduction, induction, etc., sont des cas spéciaux. Le moteur d’inférence est le programme qui réalise les déductions logiques d’un système expert à partir d’une base de connaissances (faits) et d’une base de règles [1].
Quand on dit que OWL DL est fondé sur une logique descriptive (d’où son nom, OWL Description Logics), on fait référence à un domaine de recherche étudiant la logique, donc conférant à OWL DL son adaptation au raisonnement automatisé.

Logiques descriptives

Quelques mots sur ces logiques descriptives [2] ou DL. C’est une famille de formalismes conçue pour décrire et raisonner sur les connaissances d’un domaine. Par exemple, la formule pour caractériser un éléphant comme un "Mammifère qui a une trompe (qui est une partie du corps) et qui est seulement de couleur grise" peut être représentée en utilisant la description suivante :

JPEG - 4.4 ko

La modélisation des connaissances d’un domaine avec les DL se réalise en deux niveaux. Le premier, le niveau terminologique ou TBox, écrit les connaissances générales d’un domaine alors que le second, le niveau assertionnel ou ABox, représente une instanciation spécifique. Une TBox comprend la définition des concepts et des rôles, alors qu’une ABox contient un ensemble d’assertions sur les individus.
Par exemple, la formule définie en position 6 dans le tableau ci-dessous (les noms débutant par une majuscule désignent les concepts, alors que ceux débutant par une minuscule dénomment les rôles), qui signifie qu’être Père c’est être à la fois Homme et Parent, sera définie dans la TBox.

GIF - 4.7 ko
Une base de connaissances de la famille composée d’une TBox

Une ABox désigne des individus caractérisés par des assertions d’individus nommés.
L’exemple du tableau suivant comprend les individus nommés suivants : Pierre, Sophie, Jean, Marie et Catherine.


GIF - 5.7 ko
ABox de la famille

Il existe de très nombreux moteurs d’inférences (Racer, Pellet, FaCT, FaCT++, Flora, Jena, Jess, Bossam...) pour raisonner sur des logiques de description. La plupart acceptent en entrée des fichiers OWL. Par exemple, Racer le moteur d’inférence sans doute le plus connu, commercialisé par Racer Systems GmbH & Co. KG, fondé en 2004 par des chercheurs qui travaillaient à l’université de Hambourg, travaille sur les ontologies modélisées par son langage, mais accepte des ontologies décrites en RDF ou OWL, ces dernières étant traduites vers le langage utilisé par Racer. Ce moteur d’inférence possède également son propre langage de requête nRQL (new Racerpro query Language) pour interroger les ontologies sur la ABox et la TBox.
Le moteur Pellet est plus récent. C’est un des projets du MINDSWAP Group, un groupe de recherche sur le Web sémantique de l’université du Maryland. Il est disponible en OpenSource et offre des évolutions fréquentes. Pellet travaille sur des ontologies décrites en RDF ou OWL et permet les requêtes avec RDQL et SPARQL sur la ABox et la TBox.
Comme le but de cet article n’est pas de présenter de façon exhaustive les plus et les moins de chacun des ces moteurs, mais de sensibiliser le lecteur à ces langages de règles nous allons illustrer notre propos par quelques exemples concrets sur la base du moteur Bossam choisi dans le cadre de cet article.
Considérez ce code bossam ex01.boo :

prefix builtin = http://www.etri.re.kr/2003/10/bossam-builtin#;
namespace is http://www.etri.re.kr/samples#;
rulebase rb01
{
  fact F01 is hasFather(Sam,John);
  fact F02 is hasFather(John,Jim);
  rule R01 is
     if
        hasFather(?x,?y) and hasFather(?y,?z)
     then
        hasGrandFather(?x,?z)
        and builtin:print(?x, " is the Grandfather of ",?z);
}

L’appel au moteur d’inférence se fait comme suit :

bossam.sh -rb file:///usr/local/bossam/bin/ex01.boo

La réponse est la suivante :

[Buchingae Rulebase: file:///usr/local/bossam/bin/ex01.boo]
[Bossam ReasonerApp session="Mon Oct 30 12:09:12 CET 2006"]
[In R01] Sam is the Grandfather of  Jim
fact http://bossam.com/default#Fact0 is http://www.etri.re.kr/samples#hasGrandFather(http://www.etri.re.kr/samples#Sam,http://www.etri.re.kr/samples#Jim);

Le moteur Bossam a déduit que Sam et Jim sont liés par le prédicat hasGrandFather. Prefix et namespace introduisent des espaces de nommage. Le langage de règles proprement dit est encadré dans la balise rulebase. On trouve deux faits et une règle. Les faits F01 et F02 affirment que les couples (Sam, John) et (John, Jim) sont liés par le prédicat hasFather et la règle R01 décrit une logique comptant une section condition (if) et une section conclusion (then) ; builtin:print, est une fonction builtin de Bossam.

prefix wine = http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#;
namespace is http://etri.re.kr/bossam/examples#;
rulebase Test1
{
 rule r is
 if
   wine:locatedIn(?x,wine:NapaRegion)
   and wine:hasSugar(?x,wine:Dry)
 then
   answer(?x);
}

bossam.sh -oir  file:////usr/local/bossam/bin/wine.boo  http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine [OWL Inference Rulebase: file:////usr/local/bossam/bin/wine.boo]
[OWL document: http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine]
[Bossam ReasonerApp session="Mon Oct 30 12:25:56 CET 2006"]
fact http://bossam.com/default#Fact3 is http://etri.re.kr/bossam/examples#answer(http://www.w3.org/TR/2003/PR-owl-guide-20031209/wi ne#ElyseZinfandel);
fact http://bossam.com/default#Fact1 is http://etri.re.kr/bossam/examples#answer(http://www.w3.org/TR/2003/PR-owl-guide-20031209/wi ne#PageMillWineryCabernetSauvignon);
fact http://bossam.com/default#Fact4 is http://etri.re.kr/bossam/examples#answer(http://www.w3.org/TR/2003/PR-owl-guide-20031209/wi ne#BancroftChardonnay);
fact http://bossam.com/default#Fact5 is http://etri.re.kr/bossam/examples#answer(http://www.w3.org/TR/2003/PR-owl-guide-20031209/wi ne#SeanThackreySiriusPetiteSyrah);
fact http://bossam.com/default#Fact6 is http://etri.re.kr/bossam/examples#answer(http://www.w3.org/TR/2003/PR-owl-guide-20031209/wi ne#WhitehallLaneCabernetFranc);
fact http://bossam.com/default#Fact0 is http://etri.re.kr/bossam/examples#answer(http://www.w3.org/TR/2003/PR-owl-guide-20031209/wi ne#FormanCabernetSauvignon);
fact http://bossam.com/default#Fact2 is http://etri.re.kr/bossam/examples#answer(http://www.w3.org/TR/2003/PR-owl-guide-20031209/wi ne#FormanChardonnay);

Exemple 1

Dans l’exemple 1 on raisonne sur la célèbre ontologie concernant les vins en cherchant la liste des vins secs dans la région de la Napa Vallée.

SWRL

Ces deux derniers exemples ont mis en avant une syntaxe propre à Bossam mais il existe des propositions de recommandations de langage de règles comme SWRL (Semantic Web Rule Language ou langage de règles du Web sémantique). SWRL est un langage qui enrichit la sémantique d’une ontologie définie en OWL. SWRL permet contrairement à OWL, de manipuler des instances par des variables (?x, ?y, ?z). SWRL ne permet pas de créer des concepts ni des relations, il permet simplement d’ajouter des relations suivant les valeurs des variables et la satisfaction de la règle. Les règles SWRL sont construites suivant ce schéma : antécédent -> conséquent.
L’antécédent et le conséquent sont des conjonctions d’atomes. Un atome est une instance de concept, une relation OWL ou une des deux relations SWRL same-as(?x, ?y) ou different-from (?x, ?y)). Le fonctionnement d’une règle est basée sur le principe de satisfiabilité de l’antécédent ou du conséquent. Pour une règle, il existe trois cas de figure :

  • l’antécédent et le conséquent sont définis. Si l’antécédent est satisfait alors le conséquent doit l’être ;
  • l’antécédent est vide, cela équivaut à un antécédent satisfait ce qui permet de définir des faits ;
  • le conséquent est vide, cela équivaut à un conséquent insatisfait, l’antécédent ne doit pas être satisfiable.

Dans l’exemple suivant, la relation estOncleDe a été construite en OWL, SWRL apporte la description de cette relation et relie les instances concernées. En effet OWL permet de définir le concept d’Oncle :

intersectionOf(SubClassOf(Homme), estfrereDe(Pere)).

Nous savons qu’une personne est un Oncle, mais nous ne savons pas de qui. OWL ne permet pas de définir une relation qui représente le fait d’être oncle d’une personne. Avec SWRL c’est possible :

aEnfant(?x,?y) ^ estfrereDe(?z,?x) ->  estOncleDe(?z,?y).

Nous allons reprendre ici l’exemple proposé par Guus Schreiber. Le fichier ulanOWL.owl (exemple 2) présente une section OWL pour définir des instances et une section SWRL. Pour saisir cet exemple il faut comprendre ce que AAT, ULAN ou VRA représentent.

<?xml version='1.0' encoding='ISO-8859-1'?>
<!DOCTYPE rdf:RDF [
<!ENTITY rdf ‘http://www.w3.org/1999/02/22-rdf-syntax-ns'>
<!ENTITY rdfs ‘http://www.w3.org/2000/01/rdf-schema'>
<!ENTITY owl ‘http://www.w3.org/2002/07/owl'>
<!ENTITY xsd ‘http://www.w3.org/2001/XMLSchema'>
<!ENTITY ruleml ‘http://www.w3.org/2003/11/swrl'>
<!ENTITY swrl ‘http://www.w3.org/2003/11/swrl'>
<!ENTITY ulan ‘http://example.org/ulan#'>
<!ENTITY aat ‘http://example.org/aat#'>
<!ENTITY aatulan ‘http://example.org/aatulan#'>
<!ENTITY vra ‘http://example.org/vra#'>
]>
<rdf:RDF
 xmlns:rdf ="&rdf;#" xmlns:rdfs="&rdfs;#" xmlns:owl ="&owl;#"
 xmlns:ruleml="&ruleml;#" xmlns:swrl="&swrl;#" xmlns:ulan="&ulan;"
 xmlns:aat="&aat;" xmlns:vra="&vra;" xmlns:aatulan="&aatulan;"
 xml:base="&ulan;#">

<!-- OWL Statements -->
<aat:Style rdf:ID="Impressionism"/>
<owl:Class rdf:ID="OrchestralWork"/>
<ulan:OrchestralWork rdf:ID="La_Mer"/>
<owl:ObjectProperty rdf:about="&aatulan;artistStyle" />
<ulan:Artist rdf:ID="Debussy">
   <aatulan:artistStyle rdf:resource="#Impressionism"/>
   <vra:creator rdf:resource="#La_Mer"/>
</ulan:Artist>

<!-- SWRL Rules -->
<swrl:Variable rdf:ID="x"/>
<swrl:Variable rdf:ID="y"/>
<swrl:Variable rdf:ID="z"/>
<ruleml:Imp>
 <ruleml:body rdf:parseType="Collection">
   <swrl:ClassAtom>
     <swrl:classPredicate rdf:resource="&ulan;Artist"/>
     <swrl:argument1 rdf:resource="#x" />
   </swrl:ClassAtom>
   <swrl:ClassAtom>
     <swrl:classPredicate rdf:resource="&aat;Style"/>
     <swrl:argument1 rdf:resource="#y" />
   </swrl:ClassAtom>
   <swrl:IndividualPropertyAtom>
     <swrl:propertyPredicate rdf:resource="&aatulan;artistStyle"/>
     <swrl:argument1 rdf:resource="#x" />
     <swrl:argument2 rdf:resource="#y" />
   </swrl:IndividualPropertyAtom>
   <swrl:IndividualPropertyAtom>
     <swrl:propertyPredicate rdf:resource="&vra;creator"/>
     <swrl:argument1 rdf:resource="#x" />
     <swrl:argument2 rdf:resource="#z" />
   </swrl:IndividualPropertyAtom>
 </ruleml:body>
 <ruleml:head rdf:parseType="Collection">
     <swrl:IndividualPropertyAtom>
     <swrl:propertyPredicate rdf:resource="&vra;styleperiod"/>
     <swrl:argument1 rdf:resource="#z" />
     <swrl:argument2 rdf:resource="#y" />
    </swrl:IndividualPropertyAtom>
  </ruleml:head>
</ruleml:Imp>

</rdf:RDF>

exemple 2

Vous avez sans doute entendu parler du Dublin Core qui regroupe un ensemble de champs de métadonnées comme title, creator, subject... pour décrire des documents, pages Web... L’ULAN pour Union List of Artists Names est un vocabulaire structuré contenant environ 220 000 noms d’artiste ainsi que d’autres renseignements à leur sujet, le AAT (The Art & Architecture Thesaurus), un thésaurus de termes employés pour le catalogage et l’indexation dans les domaines des arts, de l’architecture et le VRA, Visual Resources Association, sont des lignes directrices pour la description d’oeuvres de la culture visuelle ainsi que des images qui les documentent.
La dernière règle :

Artist(?x) ^ Style(?y) ^ artistStyle(?x,?y) ^ creator(?x,?z) -> styleperiod(?z,?y)

exprime le fait, comme l’indique l’auteur de cet exemple, que "The rule expresses the fact that, given knowledge about the Style of certain Artists (e.g.,van Gogh is an Impressionist painter), we can derive the style/period of an art objectfrom the value of the creator of the art object, where Style is a term from the Art and Architecture Thesaurus (AAT), Artist is a class from the Union List of Artist Names(ULAN), artistStyle is a property relating ULAN Artists to AAT Styles, and both creator and style/period are properties from the Visual Resources Association catalogue(VRA), with creator being a subproperty of the Dublin Core element dc:creator."
J’ai introduit une oeuvre La Mer dite impressioniste et un compositeur Debussy. Nous allons faire un test en demandant au moteur Bossom de nous donner le styleperiod de l’oeuvre musicale La Mer, demande qui se traduit par l’expression

"query q is http://example.org/vra#styleperiod (http://example.org/ulan#La_Mer,?x);"

L’interface Java de Bossam permet d’écrire ses propres raisonneurs, c’est ce nous avons fait dans l’exemple 3.

import bossam.app.IReasonerFactory;
import bossam.app.ReasonerFactory;
import bossam.app.IReasoner;

public class Boo1 {
public final static void main(String[] args)  {
IReasonerFactory reasonerFactory = ReasonerFactory.getInstance();
IReasoner r = reasonerFactory.createOwlDlReasoner();
try
{
r.load(IReasoner.SWRLRDF,"http://localhost/ulanOWL.owl");
String result = r.run();
//System.out.println(result); // you can see what are derived

result = r.ask("query q is http://example.org/vra#styleperiod(http://example.org/ulan#La_Mer,?x);");

System.out.println("result:"+result);
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

[root@ditgepc11 bin]#  java Boo1
result:{[?x = http://example.org/ulan#Impressionism]}

Exemple 3

A la ligne IReasoner r = reasonerFactory.createOwlDlReasoner() ; on spécifie que l’on va travailler sur des syntaxes SWRL, OWL, et RuleML Puis on charge l’ontologie à la ligne r.load(IReasoner.SWRLRDF,"http://localhost/ulanOWL.owl") ; puis on raisonne String result = r.run() ; puis on interroge result = r.ask("query q is http://example.org/vra#styleperiod(...) ;") ;
La réponse result :[?x = http://example.org/ulan#Impressionism] est bien en accord avec ce que l’on attend.
Dans ce autre exemple nous allons interroger une ontologie family.swrl.owl qui décrit des liens de parenté. Comme dans l’exemple précédent, cette ontologie présente une section purement OWL et une section SWRL. Cette ontologie est partiellement visualisée dans Protégé.

JPEG - 15.7 ko
exemple 4

L’exemple 4 visualise les instances M02 et M01 tandis que le 5 visualise le jeu des règles SWRL (c’est une extension proposée dans Protégé). En 4ème ligne de cette dernière figure la règle on trouve la règle hasFather que nous allons exploiter pour connaître le lien de parenté entre M01 et M02.

JPEG - 6.2 ko
exemple 5

Comme précédemment on fait appel à l’interface Java proposée dans Bossam.
Voici un extrait du programme Boo2.java

r.load(IReasoner.SWRLRDF,"http://localhost/family.swrl.owl");
r.setNamespacePrefix("p","http://a.com/ontology#");
String result = r.run();
result = r.ask("query q is p:hasFather(p:M02, p:M01);");
System.out.println("result:"+result);


[]# java Boo2
result:true

La figure suivante montre, juste à titre indicatif, une intégration de Jess (JavaMC Expert System Shell) dans Protégé. JESS propose un environnement pour la création et l’édition de systèmes à base de règles.

Inconsistance

Les moteurs d’inférence peuvent également servir à vérifier la consistance d’une ontologie qui se montre complexe. Par exemple dans Protégé sous le menu Preferences vous pouvez indiquer l’URL d’un moteur. (Pellet 1.3 dans cet exemple). Si vous chargez l’ontologie de démonstration pizza.owl et demandez une vérification de consistance on va vous signaler deux inconsistances avec IceCream et CheeseyVegetableTopping. Le problème avec CheeseyVegetableTopping c’est qu’elle hérite de deux classes disjointes CheeseTopping et VegetableTopping.


Web 3.0

Dans un article du NYTimes du 12 Novembre dernier Entrepreneurs See a Web Guided by Common Sense, son auteur John Markoff, décrit un Web 3.0 dans le but "d’ajouter une couche de sens tout en haut du web existant, pour en faire un guide au lieu d’un simple catalogue". L’article rappelle que "nous sommes en train de passer d’un web de documents connectés à un web de données connectées". Pour conclure cet ensemble d’articles sur le Web sémantique, un extrait choisi de cet article :
Web 2.0, which describes the ability to seamlessly connect applications (like geographic mapping) and services (like photo-sharing) over the Internet, has in recent months become the focus of dot-com-style hype in Silicon Valley. But commercial interest in Web 3.0 - or the "semantic Web," for the idea of adding meaning - is only now emerging.
The classic example of the Web 2.0 era is the "mash-up" - for example, connecting a rental-housing Web site with Google Maps to create a new, more useful service that automatically shows the location of each rental listing.
In contrast, the Holy Grail for developers of the semantic Web is to build a system that can give a reasonable and complete response to a simple question like : "I’m looking for a warm place to vacation and I have a budget of $3,000. Oh, and I have an 11-year-old child."

[1] Remarque : si l’acceptation de RDF et OWL, recommandations du W3C, font plus ou moins l’unanimité, la situation pour l’établissement de recommandations pour un langage de règles est plus problématique

[2] une bonne introduction, le mémoire de Tony Dujardin : De l’apport des ontologies pour la conception de systèmes multi-agents ouverts



Cherchez ...

- dans tous les Flash informatique
(entre 1986 et 2001: seulement sur les titres et auteurs)
- par mot-clé

Avertissement

Cette page est un article d'une publication de l'EPFL.
Le contenu et certains liens ne sont peut-être plus d'actualité.

Responsabilité

Les articles n'engagent que leurs auteurs, sauf ceux qui concernent de façon évidente des prestations officielles (sous la responsabilité du DIT ou d'autres entités). Toute reproduction, même partielle, n'est autorisée qu'avec l'accord de la rédaction et des auteurs.


Archives sur clé USB

Le Flash informatique ne paraîtra plus. Le dernier numéro est daté de décembre 2013.

Taguage des articles

Depuis 2010, pour aider le lecteur, les articles sont taggués:
  •   tout public
    que vous soyiez utilisateur occasionnel du PC familial, ou bien simplement propriétaire d'un iPhone, lisez l'article marqué tout public, vous y apprendrez plein de choses qui vous permettront de mieux appréhender ces technologies qui envahissent votre quotidien
  •   public averti
    l'article parle de concepts techniques, mais à la portée de toute personne intéressée par les dessous des nouvelles technologies
  •   expert
    le sujet abordé n'intéresse que peu de lecteurs, mais ceux-là seront ravis d'approfondir un thème, d'en savoir plus sur un nouveau langage.