Ontopy : programmation orientée ontologie en PythonCe travail a

Ontopy : programmation orient´ee ontologie en Python
Ontopy : programmation orient´ee ontologie
en Python?
Jean-Baptiste Lamy1, H´el`ene Berthelot1
LIMICS, Universit´e Paris 13, Sorbonne Paris Cit´e, 93017 Bobigny, France, INSERM UMRS 1142, UPMC
Universit´e Paris 6, Sorbonne Universit´es, Paris
[e-mail],[email protected]
R´esum´e : Les ontologies et les mod`eles objets partagent un vocabulaire commun mais diff`erent
dans leurs utilisations : l’ontologie permet d’effectuer des inf´erences et les mod`eles objets sont
utilis´es pour la programmation. Il est souvent n´ecessaire d’interfacer ontologie et programme objet.
Plusieurs approches ont ´et´e propos´ees, de OWL API `a la programmation orient´ee ontologie. Dans
cet article, nous pr´esentons Ontopy, un module de programmation orient´ee ontologie dynamique en
Python, et nous prendrons pour exemple la comparaison des contre-indications des m´edicaments.
Mots-cl´es : Ontologies, Programmation orient´ee ontologie, Programmation dynamique
1 Introduction
Les ontologies formelles, par exemple au format OWL (Ontology Web Language),
structurent un domaine de connaissance pour r´ealiser des inf´erences logiques et relier
les connaissances entre elles. Des ´editeurs comme Prot´eg´e rendent facile la construction
d’ontologies, mais leur int´egration `a des logiciels existants est plus compliqu´ee (Goldman
NM, 2003). Il existe des similitudes entre ontologie et mod`ele objet (Koide et al., 2005) :
les classes, propri´et´es et individus des ontologies correspondent aux classes, attributs et
instances des mod`eles objets (Knublauch et al., 2006). Cependant, les principaux outils
comme OWL API (Horridge & Bechhofer, 2011) n’en tirent pas parti : avec ces outils
une classe de l’ontologie ne correspond pas `a une classe du langage de programmation.
Ces outils sont par cons´equents complexes `a mettre en oeuvre et difficilement compatibles
avec les m´ethodes de d´eveloppement agile. Une approche diff´erente consisterait `a aller
vers le rapprochement, voire l’unification, des ontologies et des mod`eles objets : c’est la
programmation orient´ee ontologie (Goldman NM, 2003). Sur un exemple du W3C, cette
approche a permis de r´eduire de moiti´e le volume de code source (Knublauch et al., 2006).
Cet article pr´esente Ontopy, un module Python pour la programmation orient´ee onto-
logie dynamique. Ontopy permet de cr´eer et manipuler les classes et les instances OWL
comme des objets Python, et de classifier automatiquement des classes et des instances via
un raisonneur externe. Nous pr´esentons ensuite le probl`eme de la comparaison des contre-
indications des m´edicaments, que nous r´ealisons avec une ontologie et un programme
objet. Nous montrerons un exemple d’utilisation d’Ontopy dans ce contexte. OWL API
n’a pas ´et´e utilis´e car peu adapt´e `a nos m´ethodes de d´eveloppement agile, de plus nous
souhaitions r´eutiliser des outils terminologiques mis au point pr´ec´edemment en Python
(Lamy et al., 2015). Nous terminerons en comparant notre approche `a la litt´erature.
?. Ce travail a ´et´e financ´e par l’ANSM au travers du projet de recherche VIIIP (AAP-2012-013).

IC 2015
Figure 1 – Architecture g´en´erale d’Ontopy.
2 Ontopy : un module Python pour la programmation orient´ee ontologie
Ontopy est un module Python en logiciel libre (licence GNU LGPL v3, https:
//bitbucket.org/jibalamy/ontopy) pour la programmation orient´ee ontologie et le d´e-
veloppement agile d’application `a base d’ontologie. Le langage Python 3.4 a ´et´e choisi car
il s’agit d’un langage objet dynamique avec h´eritage multiple. En particulier, il permet
de changer la classe d’un objet ou les superclasses d’une classe en cours d’ex´ecution, par
exemple suite `a la classification, ce que ne permet pas un langage statique comme Java.
Ontopy permet (a) de charger des ontologies au format OWL 2 XML, (b) d’acc´eder au
contenu de l’ontologie comme s’il s’agissait d’objets Python, (c) de cr´eer des classes OWL
en Python, (d) d’ajouter des m´ethodes Python aux classes OWL, et (e) d’effectuer la clas-
sification automatique des instances, classes et propri´et´es. Les types de donn´ees suivants
sont g´er´es : bool´een, entier, flottant, date, chaˆıne de caract`eres.
Ontopy (Figure 1) n’effectue aucune inf´erence (hors mise `a jour des propri´et´es inverses)
tant que le raisonneur n’est pas appel´e explicitement. Ce comportement est similaire `a
celui de Prot´eg´e. Nous avons utilis´e le raisonneur HermiT 1.3.8 (Motik et al., 2009) auquel
nous avons ajout´e une option en ligne de commande pour obtenir en sortie la classification
des instances. La classification se fait en 3 ´etapes : (1) exporter l’ontologie dans un fichier
OWL temporaire, (2) ex´ecuter HermiT sur ce fichier, (3) r´ecup´erer la sortie d’HermiT et
appliquer les r´esultats en changeant les classes des instances et les superclasses des classes.
Python permet de modifier son mod`ele objet via un syst`eme de m´etaclasses (classe de
classe). La Table 1 montre les m´ethodes sp´eciales que nous avons red´efinies pour adapter
le mod`ele objet Python `a OWL. Deux autres diff´erences ont demand´e un traitement
particulier : (1) dans une ontologie, une instance peut appartenir `a plusieurs classes, ce
que ne permettent pas les langages objets ; dans ce cas, une classe intersection h´eritant des
diff´erentes classes est cr´e´ee automatiquement et associ´ee `a l’objet, (2) les annotations ne
sont pas h´erit´ees dans les ontologies, alors que tous les attributs le sont dans les langages
objets ; c’est pourquoi nous avons plac´e les annotations dans un dictionnaire `a part qui fait
correspondre une entit´e (ou un triplet) `a un second dictionnaire, lequel fait correspondre
les propri´et´es d’annotation `a leurs valeurs.
3 Le probl`eme de la comparaison des contre-indications des m´edicaments
Le processus complexe de r´edaction, structuration et codage des propri´et´es des m´e-
dicaments conduit `a une grande h´et´erog´en´eit´e dans les bases de donn´ees, qui com-

Ontopy : programmation orient´ee ontologie en Python
M´ethode Effet Raison de la red´efinition
C. new Cr´ee un nouvel objet Combiner la nouvelle classe `a la classe
OWL de mˆeme nom, si elle existe
C. instancecheck Teste si un objet est une
instance de la classe
Prendre en compte les classes ´equivalentes
OWL
C. subclasscheck Teste si une classe est une
sous-classe de la classe
Prendre en compte les classes ´equivalentes
OWL
C.mro Calcule l’ordre de r´esolution des
m´ethodes (method resolution
order, MRO) notamment en cas
d’h´eritage multiple
Ne pas d´eclencher d’erreur en cas de
MRO temporairement incorrect lors du
chargement de l’ontologie (les classes
parentes ´etant ajout´ees une `a une)
i. setattr Modifie un attribut de l’objet Mettre `a jour les propri´et´es inverses
i. getattr Obtient un attribut de l’objet
(appel´e uniquement pour les
attributs inexistants)
Retourner une liste vide si la propri´et´e n’a
pas ´et´e renseign´ee, ou None pour une
propri´et´e fonctionnelle
Table 1 – M´ethodes sp´eciales du mod`ele objet de Python qui ont ´et´e red´efinies pour
le rendre compatible avec OWL. Pour chaque m´ethode est indiqu´e si elle s’applique aux
classes (C.) ou aux instances (i.), son effet et la raison de sa red´efinition.
Condition clinique ticagr´elor aspirine h´eparine
maladie h´emorragique CI
maladie h´emorragique acquise CI
maladie h´emorragique constitutionnelle CI CI
Condition clinique ticagr´elor aspirine h´eparine
maladie h´emorragique CI CI CI/ok
maladie h´emorragique acquise CI CI ok
maladie h´emorragique constitutionnelle CI CI CI
Table 2 – Trois contre-indications pour trois m´edicaments, issues de la base m´edicament
Th´eriaque en haut, et telles qu’interpr´et´ees par un expert en bas (CI : contre-indiqu´e, ok :
absence de contre-indication, CI/ok : contre-indiqu´e dans certaines situations seulement).
plique la comparaison entre m´edicaments. La Table 2 (haut) montre trois exemples de
situations de contre-indication pour trois m´edicaments, extraits de la base Th´eriaque
(http://theriaque.org). Cependant, bien que cela n’apparaisse pas dans ce tableau, le ti-
cagr´elor est contre-indiqu´e avec les maladies h´emorragiques acquises et constitutionnelles,
car contre-indiqu´e dans l’ensemble des maladies h´emorragiques (h´eritage). Et l’aspirine
est contre-indiqu´ee dans les maladies h´emorragiques car contre-indiqu´ee `a la fois dans
celles acquises et constitutionnelles (partition). Enfin, il est possible de d´eduire les situa-
tions dans lesquelles un m´edicament n’est pas contre-indiqu´e, par exemple les maladies
h´emorragiques acquises pour l’h´eparine (`a ne pas confondre avec l’absence de mention
de contre-indication dans la base). La Table 2 (bas) montre l’interpr´etation que ferait un
expert ; nous souhaitons automatiser ce raisonnement.

IC 2015
Nous avons structur´e les contre-indications `a l’aide d’une ontologie formelle, dans la-
quelle les conditions cliniques associ´ees aux contre-indications sont d´ecrites par un code
dans une terminologie et un ou plusieurs qualifieurs tels que “acquise”, “constitutionnel-
le”, “ant´ec´edent”,... Ces conditions cliniques sont repr´esent´ees par des classes et non des
instances, afin de pouvoir prendre en compte les relations est-un existant entre conditions
cliniques (par exemple maladie h´emorragique acquise est une maladie h´emorragique).
4 Exemple d’utilisation d’Ontopy
Nous donnons ici un exemple d’application d’Ontopy au probl`eme de la comparaison des
contre-indications. Ontopy charge les ontologies `a partir des r´epertoires locaux d´efinis dans
la variable globale onto_path, ou `a d´efaut `a partir de leur URL. onto_path se comporte
comme le classpath de Java ou le pythonpath de Python, mais pour les fichiers OWL.
from ontopy import *
onto_path.append("/chemin/local/des/ontos")
onto_ci = get_ontology("http://test.org/onto_ci.owl").load()
#charge /chemin/local/des/ontos/onto_ci.owl ou http://test.org/onto_ci.owl
L’ontologie peut ensuite ˆetre utilis´ee comme un module Python, et la nota-
tion point´ee usuelle permet d’acc´eder aux ´el´ements de l’ontologie. Des attributs
(imported_ontologies,classes,properties, etc) permettent de r´ecup´erer la liste des
´el´ements d’un type donn´e.
onto_ci.M´edicament # La classe http://test.org/onto_ci.owl#M´edicament
Les classes de l’ontologie peuvent ˆetre instanci´ees en Python. La notation point´ee permet
d’acc´eder aux relations des instances. Les relations fonctionnelles ont une valeur unique,
les autres sont des listes.
aspirine = onto_ci.M´edicament("aspirine") # onto_ci.owl#aspirine
aspirine.noms_de_marque = ["Aspirine du Rh^one", "Aspirine UPSA"]
Il est possible de cr´eer des classes OWL en Python, en h´eritant de Thing ou d’une classe
fille. Les attributs is_a et equivalent_to sont des listes correspondant aux superclasses
et aux classes ´equivalentes OWL. Ces listes peuvent contenir des classes, mais aussi des
restrictions portant sur une propri´et´e (d´efinies de mani`ere similaire `a Prot´eg´e), des ´enum´e-
rations d’instances (one of ), ou plusieurs de ces ´el´ements reli´es par des op´erateurs logiques
ET (&), OU (|) ou NON (NOT). Les classes pr´esentes dans is_a sont ajout´ees aux su-
perclasses Python, en revanche les autres ´el´ements ne sont pas trait´es comme des classes
par Ontopy. L’exemple ci-dessous cr´ee la classe des maladies h´emorragiques acquises, fille
de Condition_clinique, et d´efinie comme ´equivalente `a une condition clinique associ´ee
au terme “maladie h´emorragique” et ayant pour qualifieur Acquis.
class Maladie_h´emorragique_acquise(onto_ci.Condition_clinique):
equivalent_to = [ onto_ci.Condition_clinique
& onto_ci.a_pour_terme (SOME, onto_ci.Terme_maladie_h´emorragique)
& onto_ci.a_pour_qualifieur(SOME, onto_ci.Acquis) ]
Nous pouvons ensuite cr´eer la premi`ere contre-indication et la relier `a l’aspirine.
ci1 = onto_ci.Contre_indication()
aspirine.a_pour_contre_indication.append(ci1)

Ontopy : programmation orient´ee ontologie en Python
Relier cette contre-indication aux maladies h´emorragiques acquises est un peu plus com-
pliqu´e, car il s’agit d’une classe et non d’une instance. Pour cela nous modifions les attri-
buts is_a de la classe Maladie_h´emorragique_acquise et de l’instance ci1. L’attribut
is_a d’une instance fonctionne de mani`ere similaire `a celui d’une classe, mais contient les
classes auxquels appartient l’instance. Ci-dessous, nous sp´ecifions que la contre-indication
est reli´ee seulement `a des maladies h´emorragiques acquises, et que la classe des maladies
h´emorragiques acquises est reli´ee `a notre contre-indication.
ci1.is_a.append(
onto_ci.a_pour_condition_clinique(ONLY, Maladie_h´emorragique_acquise) )
Maladie_h´emorragique_acquise.is_a.append(
onto_ci.est_condition_clinique_de(VALUE, ci1) )
Cr´eons ensuite la classe d´efinie des conditions cliniques contre-indiqu´ees avec l’aspirine.
class Condition_CI_avec_aspirine(onto_ci.Condition_clinique):
equivalent_to = [ onto_ci.Condition_clinique
& onto_ci.est_condition_clinique_de(SOME, onto_ci.Contre_indication
& onto_ci.est_contre_indication_de(VALUE, aspirine) ) ]
Ontopy permet aussi l’ajout de m´ethodes Python aux classes OWL, en red´efinissant les
classes dans un module Python. Ce module peut ˆetre li´e `a l’ontologie via une annota-
tion, de sorte `a ˆetre charg´e automatiquement avec l’ontologie. L’exemple suivant ajoute
une m´ethode teste_ci `a la classe M´edicament. Elle prend en param`etre une classe de
condition clinique et retourne une chaˆıne de caract`eres. La m´ethode r´ecup`ere la classe des
conditions cliniques contre-indiqu´ees avec le m´edicament, en se basant sur son nom, et
teste si la condition clinique est une classe fille avec l’op´erateur issubclass de Python.
Puis nous lan¸cons le raisonneur et nous affichons les r´esultats.
class M´edicament(Thing):
def teste_ci(self, Condition):
Condition_CI = onto_ci["Condition_CI_avec_" + self.name]
if issubclass(Condition, Condition_CI): return "CI"
[...] # XXX tester si le m´edicament est OK
onto_ci.sync_reasoner() # Lance HermiT et effectue la classification
print(aspirine.teste_ci(Maladie_h´emorragique)) # => "CI"
5 Discussion et conclusion
La programmation orient´ee ontologie n’est pas une id´ee nouvelle et le W3C a d´ej`a
sugg´er´e l’int´egration de m´ethodes dans des classes OWL (Knublauch et al., 2006). Des
approches statiques ont ´et´e propos´ees (Kalyanpur et al., 2004; Goldman NM, 2003), qui
g´en`erent le code source de classes Java ou C# correspondant `a une ontologie en OWL. Ces
approches permettent d’acc´eder `a l’ontologie et de v´erifier le typage `a la compilation, mais
leur nature statique n’est pas adapt´ee `a la classification automatique. Plus r´ecemment,
une approche semi-dynamique en Java (Stevenson & Dobson, 2011) a permis la classifica-
tion des instances mais pas celle des classes. Une approche dynamique a ´et´e propos´ee en
Common Lisp (Koide et al., 2005), en utilisant un algorithme de subsomption sp´ecifique
pour l’inf´erence et non un raisonneur externe. Un prototype en Python a aussi ´et´e r´ealis´e
(Babik & Hluchy, 2006), mais ne va pas jusqu’`a une syntaxe “enti`erement Python” pour