Après avoir vu comment construire son ontologie à partir de classes et de propriétés existantes, je vous propose d'étudier la définition des classes et des propriétés dans votre propre ontologie.

Type, Classe, instance

Définir une classe n'est pas si évident qu'il n'y paraît.

Premier problème : définir un concept générique et les différentes natures de ce concept. Prenons un exemple : un lieu. Il peut être de nature différente : un pays, une région, une ville, un quartier, une forêt... Une tendance naturelle, venant en partie des habitudes des bases de données relationnelles, nous pousse à créer une classe générique pour définir le concept de lieu et d'avoir une propriété type permettant de préciser la nature du lieu. Dans le monde RDF et a-fortiori dans le monde OWL, le type d'une classe équivaut à une sous-classe.

Cette notation :

<lieu>
   <nom>Paris</nom>
   <rdf:type rdf:resource="#ville"/>
</lieu>

équivaut à :

<ville>
  <nom>Paris</nom>
</ville>

Le premier exemple est tout à fait correct. Vous n'aurez d'ailleurs pas besoin de déclarer la propriété rdf:type dans la définition de votre ontologie, puisqu'il s'agit d'une propriété définie dans la spécification de RDF. En revanche, cette notation n'est juste que si vous avez défini la classe lieu et la classe ville, comme une sous-classe de lieu. Par conséquent, dès que vous avez la tentation de définir une propriété type ou nature pour une classe, retenez-vous et créez plutôt des sous-classes correspondant à chaque type ce qui donnera pour mon exemple :

<owl:Class rdf:ID="lieu">
  <rdfs:label xml:lang="fr">Lieu</rdfs:label>
</owl:Class>
<owl:Class rdf:ID="ville">
  <rdfs:label xml:lang="fr">Ville</rdfs:label>
  <rdfs:subClassOf rdf:resource="#lieu"/>
</owl:Class>

Évidemment, cela oblige à penser les différents types d'un concept au moment de l'élaboration de l'ontologie. Mais, c'est bien l'essence même de l'exercice : modéliser les informations et les connaissances d'un domaine en essayant de tendre à l'exhaustivité.

Dans ces conditions, vous allez me demander quelle est la différence entre une sous-classe et les instances d'une classe et c'est vrai que cela peut poser des problèmes. On pourrait tout de même édicter une règle pour différencier les classes et les instances. Une classe représente les concepts et les types abstraits et les instances représentent les individus attribués à une classe dans le monde réel. Par exemple, « Paris » est une instance de la classe ville et pas une sous-classe de ville, car Paris n'est pas une notion abstraite qui renverrait à un type particulier de ville.

Les différents types de propriétés

Un fichier RDF, et donc un fichier OWL, se traduit par une suite de triplets ou déclarations de la forme : Sujet – prédicat – objet. Si cela vous semble flou, je vous renvoie à un précédent billet. Les différents prédicats utilisés dans une ontologie sont définis par les propriétés. Le langage OWL différencie deux types de propriétés :

1. les propriétés d'objet (objectProperty) qui relie deux instances de classes ;

2. les propriétés de type de données (dataTypeProperty) qui relie une instance de classe à une valeur de données.

Soit la déclaration suivante : toto est le frère de titi. « Toto » est le sujet, « est frère de » est le prédicat et « titi » est l'objet. Toto et Titi sont deux instances d'une classe personne. « est frère de » est une propriété d'objet de la classe personne qui relie deux instances de cette même classe. Cette propriété sera définie de la manière suivante dans mon ontologie :

<owl:objectProperty rdf:ID="estFrereDe">
  <rdfs:label xml:lang="fr">est frère de</rdfs:label>
  <!-- Définition de la classe qui sera sujet de cette propriété -->
  <rdfs:domain rdf:resource="#personne"/>
  <!-- Définition de la classe qui sera objet de cette propriété -->
  <rdfs:range rdf:resource="#personne"/>
</owl:objectProperty>
<owl:Class rdf:ID="personne"/>

Une fois, la propriété et la classe définies, la déclaration s'écrit ainsi en RDF/XML :

<personne rdf:ID="toto">
  <estFrereDe rdf:resource="#titi"/>
</personne>

Le principe est le même pour définir une propriété de type de données, si ce n'est que la définition de l'objet renvoie à un type de données défini dans la norme XML schema. Poursuivons l'exemple précédent. Soit la déclaration : la personne #toto a pour nom « toto ». La personne « #toto » est le sujet, « a pour nom » est le prédicat et « toto » est l'objet. La personne #toto est une instance de la classe personne. « a pour nom » est une propriété de type de données de la classe personne qui relie une instance de la classe personne et une chaîne de caractères. Cette propriété est définie de la manière suivante dans mon ontologie :

<owl:DatatypeProperty rdf:ID="nom">
  <rdfs:label xml:lang="fr">a pour nom</rdfs:label>
  <rdfs:domain rdf:resource="#personne"/>
  <!-- Lien vers la définition d'une chaîne de caractères dans la norme XML schéma -->
  <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

Si on complète l'exemple donné plus haut, on obtient :

<personne rdf:ID="toto">
  <nom>Toto</nom>
  <estFrereDe rdf:resource="#titi"/>
</personne>
<personne rdf:ID="titi">
  <nom>Titi</nom>
</personne>

Finalement, si vous n'êtes pas un habitué de la modélisation et de la notation UML, un des moyens de réfléchir à la définition d'une ontologie est d'écrire toutes les informations caractéristiques du domaine que vous voulez modéliser dans votre ontologie sous forme de phrases simples que vous traduisez ensuite en OWL, de la même manière que les exemples précédents.