Introduction

OWL est vraiment un gros morceau! Et la notion d’ontologie (ou ontology si on utilise le terme anglais) web aussi. Bien sur il existe de nombreux articles, la plupart rédigés en anglais, sur ce domaine et la plupart totalement obscure. En fait, quand j’ai commencé à travailler sur OWL, j’ai trouvé que globalement toute la lecture sur ce domaine été obscure (et je suis pas loin de toujours trouver la même chose), surtout quand on sait que OWL repose sur RDF qui lui peut être très simple, voir mon précédent article: RDF et la forme N3.

Bon, je vais essayer de rester simple, mais je ne promet pas d’être toujours compréhensible car OWL est vraiment quelques chose de compliqué, vous allez me demander “mais pourquoi OWL est-il si compliqué”. Une des raison essentielle est que OWL repose sur des principes mathématique ensembliste complexe et que OWL est un monde ouvert “Open World” comme on dit. Tout est possible en OWL car rien n’est fixé ce qui en augmente la complexité, je reviendrais à plusieurs reprise sur cette notion de monde ouvert.

Définitions

Quelques définitions:

• Ontologie: C’est un modèle de données représentatif d’un ensemble de concepts dans un domaine, ainsi que les relations entre ces concepts au sein de ce domaine. Une ontologie modélise un ensemble de connaissance sur un domaine. Une ontologies est constitué d’un ensemble d’objet tel que des individus, des classes, des attributs, des relations, des événements, …
  • Individus : les objets de base
  • Classes : ensembles, collections, ou types d’objets
  • Attributs : propriétés, fonctionnalités, caractéristiques ou paramètres que les objets peuvent posséder et partager
  • Relations : les liens que les objets peuvent avoir entre eux
  • Événements : changements subis par des attributs ou des relations
• OWL: Ontology Web Language (Language d’Ontologie Web) est une représentation en XML basé sur la syntaxe RDF d’une Ontologie. Il permet de définir des ontologie pour le web sémantique. OWL est une extension de RDF et RDFS (RDF Schema). Il existe trois niveau dans OWL: OWL-Lite, OWL-DL (celui sur lequel je me base ici) et OWL-Full. Les niveau de complexité allant croissant dans les versions. Aucun logiciel/framework à ce jour ne gère totalement OWL-Full. Je ne vais pas m’étendre sur les différences entre les trois, elle se trouve principalement au niveau des capacité d’inférence. Voir le document du W3C
  • RDF: voir la définition dans mon article RDF et la forme N3.
  • RDFS ou RDF Schema: C’ est un langage extensible de représentation des connaissances. RDFS fournit des éléments de base pour la définition d’ontologies ou vocabulaires destinés à structurer des ressources RDF.
• Inférence: “opération mentale qui consiste à tirer une conclusion d’une série de propositions reconnues pour vraies”. Appliqué à OWL, inféré une ontologie conciste à en tirer une série de nouveau objet qui découle de la définition des objets dans l’ontologie (par exemple, ajout d’attribut sur un Individus ou d’individus dans une classe). On utilise pour ceci un moteur d’ingérence, aussi appelé raisonneur (reasonner).
• Moteur d’inférence (raisonneur ou reasonner en anglais): Moteur qui permettent de raisonner ou d’inférer sur une ontologie. Je vais utiliser dans cet exemple Pellet.
• OWL-API: framework OWL Java. Ce framework que je vais présenter ici facilite la programmation d’une ontology. On aurais aussi put par exemple utiliser Jenna que j’ai présenté dans mon article: RDF et la forme N3.
• Protégé: Logiciel JAVA permettant de facilement éditer un fichier OWL. En effet, un fichier OWL est quasiment illisible par un humain, il nécéssite donc un éditeur. Protégé permet aussi d’utiliser un raisonneur, on peut donc directement vérifier et raisonner sur l”‘ontologie créée.

Exemple d’ontologie OWL en utilisant OWL-API, Pellet, protégé

Création d’une ontologie simple avec Protégé

Personnellement, j’utilise Protégé en version 3.4 Béta car elle permet directement l’utilisation de Pellet comme raisonneur. Comme j’utilise aussi Pellet dans mes programmes Java, je pense que le choix est judicieux.

Au lancement de Protégé, il vous faut créer un nouveau projet de type OWL/RDF File, lui donner une URI (sur le web, tout est URI), définir le type OWL-DL, lancer la vue Logique puis aller sur la partie éditeur de classe, et vous voila prêt à créer votre première ontologie. Ci dessous, quelques screenshot de ces étapes.

On va maintenant créer une petite ontologie basique pour tester en comprendre les fonctionnalités de base de OWL. Vois allez donc créer une classe “Category”, dans laquelle vous allez créer deux sous classes “ProductCategory” et “PriceCategory”, puis une classe “Offer”. Bon, l’exemple n’est peut être pas idéal d’un point de vue fonctionnel, mais vous voyez tout de suite ce que je veut définir, une Offre qui va contenir une category de produit (internet par exemple) et une catégorie de prix (chère par exemple).. Ci dessous, quelques screenshot pour la création des classes.

Maintenant, mettons quelques propriétés à ces classes, comme un nom par exemple, et aussi, lions les entres-elles (donc, lions ProductCategory et PriceCategory à Offer).

Créons maintenant quelques individus pour créer notre ontologie.

Voila notre ontologie créé, Protégé nous permet de la vérifier, de la classifié ou d’inférer dessus. L’inférence permet de ‘raisonner’ sur l’ontologie pour en déduire des propriété ou des élément non dit. J’expliquerais plus en détail mais c’est là que Pellet entre en action. Et voici le dernier screenshot de cet article:

Utilisation de OWL-API et de Pellet pour interroger cette Ontologie

1. Chargement de l’ontologie

Charger une ontologie avec OWL-API est déjà en soit quelque chose de complexe! Voici un morceau de code JAVA permettant de charger le fichier créer par Potégé si il est dans un répertoire owl dans le classpath:

//charge l'ontologie depuis un fichier
URL ontologyUrl = Thread.currentThread().getContextClassLoader().getResource( "owl/owl-test.owl" );
URI ontologyURI = URI.create( ontologyUrl.toExternalForm() );

//initialise un manager et un reasonner (on utilise Pellet pour ça)
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
OWLReasoner reasoner = new Reasoner( manager );

//utilise le manager pour charger ontologie
OWLOntology ontology = manager.loadOntologyFromPhysicalURI( ontologyURI );

//charge l'ontologie dans le reasonner, vérifie la consistence et classifie
//l'ontologie pour pouvoir raisonner dessus.
reasoner.loadOntologies( manager.getImportsClosure( ontology ) );
boolean isConsistent = reasoner.isConsistent( ontology );
reasoner.classify();

//instancie une data factory
OWLDataFactory dataFactory = manager.getOWLDataFactory();

On remarque ici la création des objets suivant permettant d’accéder à l’ontologie:

• OWLReasoner: on utilise Pellet comme raisonneur, il nous permettra d’accéder à l’ontologie.
• OWLDataFactory: un des composant de OWL-API qui permet d’accéder à l’ontologie
• OWLOntology: elle contient elle-même une série de méthode d’accès

Effectivement, plusieurs objets sont nécessaire pour interroger l’ontologie, l’utilisation de l’un ou l’autre dépendant de ce que nous cherchons dans l’ontologie. Des exemples vont suivre.

2. Interrogation de l’ontologie

2.1 récupération d’un individu

Tout d’abord, nous allons essayer de récupérer un Individus de notre ontologie. Par exemple, récupérer une Offer précise. il faut savoir que en OWL, tout identifiant est en fait une URI. Si vous vous rappelez bien, en début d’article, j’ai demander à Protégé de me créer une ontologie ayant l’URI: http://www.domain.com/owltest, un individus a donc comme identifiant l’URI de base + son nom (à ne pas confondre avec la valeur de la propriété hasName telle que définie dans nos classes). Ce qui donne donc comme URI pour notre unique individus de la classe Offer: http://www.domain.com/owltest#W800i

Voici donc, comment récupérer cet individus depuis l’ontologie:


OWLIndividual individual = dataFactory.getOWLIndividual( URI.create("http://www.domain.com/owltest#W800i") );

2.2 récupération de tout les individus d’une classe

On veut maintenant récupérer depuis l’ontologie tout les individus de la classe Offer. Pour cela, on doit utiliser une méthode du raisonneur. En effet, le raisonneur pouvant inférer des individus dans une classe, il est nécessaire d’utiliser le raisonneur si on veut pouvoir récupérer tout les individus d’une classes (ceux déclaré et ceux inféré). Voici:

OWLClass clazz = dataFactory.getOWLClass(URI.create("http://www.domain.com/owltest#Offer") );
Set<OWLIndividual> individuals = reasoner.getIndividuals( clazz , true );

2.3 Recherche de la PriceCategory d’une Offer

Lorsque OWL-API nous retourne un objet, il ne contient pas les éléments qui lui sont associé. Pour récupérer la PriceCategory qui est lié à une Offer, il nous faut donc ré-interroger l’ontologie. Voici un petit exemple de code:

OWLObjectProperty property = dataFactory.getOWLObjectProperty(URI.create("http://www.domain.com/owltest#hasPriceCategory"));
reasoner.getRelatedIndividuals( individual , property );

2.4 Pour aller plus loin

Si vous voulez aller plus loin, il vous faudra fouiller la doc de OWL-API, tester ses tutoriels et regarder sa JavaDoc. Je vais juste revenir ici sur deux point qui à mon sens sont un peut compliqué:

Open World et Inférence : On dit que OWL est un monde ouvert, au fil de la lecture dans OWL vous verrez peut être des choses un peut bizarre. Parfois, pour rechercher précisément quelque chose dans une ontologie, il faut créer une classes qui contient les spécificité de vos objet rechercher,l’ajouter à l’ontologie, inférer grâce à un raisonneur et ensuite charger les individus de cette classe et vous avez votre réponse. C’est dans ce sens que OWL est un monde ouvert, tout est possible à partir d’une ontologie … mais ce qu’elle ne définie pas. C’est aussi pour cela que OWL-API ne jette jamais d’exception du type: “Class Not Found” et retourne systématiquement des listes.

Conclusion, mon avis

J’ai dans cet article à peine gratter la surface à propos de OWL et de l’utilisation de OWL-API et Pellet. En effet, cette API est très dense.

Mon avis au sujet de OWL: OWL est très complexe et ne devrait être utilisé que si toutes les fonctionnalité d’une ontologie sont nécessaire, sinon, une utilisation simple de RDF (voir RDF dans sa forme N3 comme dans présenté ici: RDF et la forme N3.

Mon avis au sujet de OWL-API et de Pellet. Pellet comporte quelques limitation (assez complexe, je ne rentrerais pas dans les détails ici) mais fonctionne globalement bien. OWL-API est une API calqué sur la définition de OWL, elle est donc fort complexe et très dense (il existe des centaines de méthodes d’interrogation d’une ontology enter celle du raisonneur, de la datafactory ou de l’ontology elle-même). De plus, bien souvent, on ne sait pas trop quel objet utilisé pour récupérer l’information nécessaire entre les trois objets principaux que sont l’ontology, la data factory et le raisonneur. La documentation de OWL est pour moi réellement insuffisante: tutoriel fort théorique et JavaDoc quasi nulle. La communauté de développement de OWL-API est plutôt réduite, j’ai eu l’impression que cette API avait été créée par des universitaire pour des universitaire et l’utiliser dans un contexte d’entreprise a été assez compliqué. Jenna dont j’ai parlé dans mon article RDF et la forme N3 (je sais, je me répète) permet aussi d’interroger des ontology et je le conseillerais de préférence à OWL API.

Voici les sources de cet articles : OwlTest.java et owl-test.owl

N’hésitez pas à me faire parvenir vos avis et questions sur OWL.

Liens

• OWL chez le W3C: http://www.w3.org/2004/OWL/
• Pellet: http://pellet.owldl.com/
• Protégé: http://protege.stanford.edu/
• OWL-API: http://owlapi.sourceforge.net/