Accéder aux ontologies en Python

>>> from owlready2 import * 

Charger une ontologie

Owlready permet de charger des ontologies OWL en Python et d’accéder aux entités OWL comme l’on accéderait à des objets « traditionnels » dans un module Python. Une ontologie peut être chargée de trois manières différentes :

>>> onto = get_ontology("http://lesfleursdunormal.fr/static/ \ 
                                 _downloads/bacterie.owl").load() 

L’ontologie est alors téléchargée depuis Internet puis chargée.

>>> onto = get_ontology("/home/jiba/owlready/bacterie.owl").load() 

ou sous Windows :

>>> onto = get_ontology("C:\\owlready\\bacterie.owl").load() 

>>> onto = get_ontology("bacterie.owl").load() 

>>> onto.imported_ontologies  
[] 

Parcourir le contenu de l’ontologie

L’objet ontologie possède de nombreuses méthodes pour parcourir les entités contenues dans l’ontologie, selon leur type. Le tableau suivant récapitule l’ensemble de ces méthodes :

Ces méthodes retournent des générateurs (voir chapitre Le langage Python : adoptez un serpent ! - section Les générateurs) ; pour afficher le contenu, il faut utiliser la fonction list() de Python qui convertit le générateur en une liste :

>>> onto.classes()  
<generator object _GraphManager.classes at 0x7f5a000fae58>  
 
>>> list(onto.classes())  ...

Accéder aux entités

Lors du chargement, Owlready analyse le fichier de l’ontologie et le traduit automatiquement sous la forme d’un graphe RDF sous forme de triplets de la forme « sujet - verbe - objet » (nous reviendrons plus en détail sur RDF au chapitre Travailler avec les triplets RDF et les mondes). Ce graphe RDF est stocké dans une base de données au format SQLite3, qui réside par défaut en mémoire vive (mais la base de données peut également être stockée sur le disque, comme nous le verrons à la section Ontologie volumineuse et cache disque). Ensuite, les objets Python permettant d’accéder aux entités contenues dans l’ontologie sont créés dynamiquement à la demande. Ainsi, si une ontologie comprend 100 classes, mais qu’une seule est utilisée en Python, seule cette classe sera créée en Python et les 99 autres resteront au niveau du graphe RDF.

Le pseudo-dictionnaire IRIS permet d’accéder à une entité à partir de son IRI. Par exemple, pour accéder à l’individu bactérie_inconnue dont l’IRI complète est la suivante : http://lesfleursdunormal.fr/static/_downloads/bacterie.owl#bactérie_inconnue

nous indiquerons :

>>> IRIS["http://lesfleursdunormal.fr/static/_downloads/ \ 
bacterie.owl#bactérie_inconnue"] 

Cependant, cette notation est longue. Owlready permet d’accéder plus simplement aux entités présentes dans l’ontologie avec la notation pointée « . », comme si l’ontologie était un module Python contenant des classes et des objets. Par exemple, nous pouvons aussi accéder à l’individu bactérie_inconnue de la manière suivante :

>>> onto.bactérie_inconnue 

Lorsque la notation pointée est utilisée, Owlready prend l’IRI de base de l’ontologie (onto.base_iri, ici « http://lesfleursdunormal.fr/static/_downloads/bacterie.owl# ») et ajoute ce qui figure après le point (ici, bactérie_inconnue) pour obtenir l’IRI de l’entité demandée.

Certaines IRI peuvent contenir des caractères non acceptés par Python dans les noms d’attribut...

Rechercher des entités

La méthode search() de l’objet ontologie permet de rechercher des entités à partir de leur IRI et/ou de leurs relations. Lors de la recherche, les mots-clefs suivants sont utilisables et combinables entre eux :

De plus, dans les chaînes de caractères, des « * » peuvent être utilisées comme joker. L’exemple suivant recherche l’ensemble des entités dont l’IRI contient « Coque » :

>>> onto.search(iri = "*Coque*")  
[bacterie.Coque] 

Par défaut, la recherche est sensible à la casse. Le paramètre _case_sensitive permet de changer ce comportement, par exemple :

>>> onto.search(iri = "*Coque*", _case_sensitive = False)  
[bacterie.Coque, bacterie.Staphylocoque, bacterie.Streptocoque] 

Cette fois-ci, nous trouvons davantage de résultats, car les classes Staphylocoque et Streptocoque contiennent bien coque, mais avec un « c » minuscule et non majuscule.

Le résultat...

Ontologie volumineuse et cache disque

Gene Ontology (GO) est une ontologie très utilisée en bioinformatique qui est assez volumineuse (près de 200 Mo). Le chargement de GO, à l’aide de la commande suivante, prend plusieurs dizaines de secondes, voire quelques minutes, en fonction de la puissance de l’ordinateur et du temps de téléchargement du fichier OWL (environ 170 Mo) :

>>> go = get_ontology("http://purl.obolibrary.org/obo/go.owl").load() 

Par défaut, Owlready stocke le quadstore contenant l’ontologie au format RDF en mémoire vive. À la fin de l’exécution du programme Python, le quadstore est perdu, et le fichier OWL devra être rechargé la prochaine fois. Afin d’éviter ces rechargements longs, il est possible de placer le quadstore sur le disque, à l’aide de la méthode default_world.set_backend().

Ensuite, default_world.save() permet de l’enregistrer. Par exemple :

>>> default_world.set_backend(filename = "quadstore.sqlite3")  
>>> go = get_ontology("http://purl.obolibrary.org/obo/go.owl").load() 
>>> default_world.save() 

Nous avons ici utilisé un chemin de fichier relatif pour le quadstore, nous aurions pu indiquer un chemin absolu (par exemple "/home/jiba/owlready/quadstore.sqlite3" sous Linux/Mac...

Espaces de nommage

Certaines ontologies définissent des entités dans un espace de nommage qui n’est pas le leur ; c’est le cas de GO. L’IRI de GO est http://purl.obolibrary.org/obo/go.owl, ses entités possèdent des IRI qui commencent par http://purl.obolibrary.org/obo/ (sans le « go.owl »). Par conséquent, il n’est pas possible d’utiliser l’objet ontologie go pour accéder aux entités avec la notation pointée :

>>> go.GO_0035065  
None 

En effet, la ligne ci-dessus correspond à l’IRI http://purl.obolibrary.org/obo/go.owl#GO_0035065 tandis que la vraie IRI du concept est http://purl.obolibrary.org/obo/GO_0035065 (donc sans le « go.owl »).

Pour accéder aux entités de GO, il est possible d’utiliser le pseudo-dictionnaire global IRIS (voir Accéder aux entités). Une autre possibilité plus facile est de créer un espace de nommage (namespace en anglais) pour l’IRI « http://purl.obolibrary.org/obo/ », de la manière suivante :

>>> obo = get_namespace("http://purl.obolibrary.org/obo/") 

L’espace de nommage obo peut ensuite être utilisé pour accéder aux entités avec la notation pointée :

>>> obo.GO_0035065  
obo.GO_0035065  
>>> obo.GO_0035065.label  
['regulation...

Modifier le rendu des entités

Par défaut, Owlready affiche le nom de l’entité, précédé d’un point et du dernier morceau de l’IRI (sans l’extension .owl). Cependant, lorsque les noms des entités sont des identifiants arbitraires, cet affichage n’est pas satisfaisant, comme dans l’exemple suivant :

>>> obo.GO_0035065  
obo.GO_0035065 

La fonction globale set_render_func() permet de redéfinir la manière dont Owlready effectue le rendu des entités (rendering en anglais). Dans l’exemple suivant, nous utilisons la propriété d’annotation label pour effectuer le rendu, ou, à défaut, le nom de l’entité (c’est-à-dire son identifiant).

>>> def mon_rendu(entity):  
...       return entity.label.first() or entity.name  
>>> set_render_func(mon_rendu)  
>>> obo.GO_0035065  
regulation of histone acetylation 

Dans GO, la quasi-totalité des entités sont des classes (et non des individus ; c’est une pratique assez courante dans les ontologies biomédicales). Comme vu précédemment (voir section Restrictions existentielles) il est possible d’accéder aux restrictions existentielles de ces classes avec la notation pointée (où RO_0002211 est le nom GO pour la propriété...

Répertoire local d’ontologies

Owlready peut également fonctionner avec un ou plusieurs répertoires contenant des copies locales d’ontologies. Celles-ci seront utilisées en priorité, au lieu de télécharger les ontologies sur Internet. Le ou les répertoires locaux doivent être renseignés dans la variable globale onto_path, de la manière suivante sous Unix/Linux/Mac :

>>> onto_path.append("/home/jiba/owlready")  
>>> onto = get_ontology("http://lesfleursdunormal.fr/static/ \ 
                        _downloads/bacterie.owl#").load() 

et sous Windows :

>>> onto_path.append("C:\\owlready")  
>>> onto = get_ontology("http://lesfleursdunormal.fr/static/ \ 
                        _downloads/bacterie.owl#").load() 

La variable globale onto_path contient une liste (vide par défaut) de répertoires locaux d’ontologies. Avant de télécharger une ontologie sur Internet, Owlready vérifie si une copie n’est pas disponible dans un des répertoires locaux. Dans l’exemple précédent, si un fichier bacterie.owl est présent dans le répertoire de cache (/home/jiba/owlready ou C:\\owlready), ce fichier est utilisé....

>>> go = get_ontology("http://purl.obolibrary.org/obo/go.owl#") \ 
                         .load(reload_if_newer = True) 

Exemple : créer un site web dynamique à partir d’une ontologie

Dans cet exemple, nous allons générer un site web dynamique pour présenter les classes et les individus d’une ontologie. Pour cela, nous utiliserons Owlready ainsi que Flask, un module Python qui permet de réaliser facilement des sites web. Flask permet d’associer un chemin sur un site web à une fonction Python; lorsque ce chemin est demandé, la fonction est appelée et celle-ci doit retourner la page HTML correspondante. Le chemin est défini en ajoutant @app.route(’/chemin’) sur la ligne précédant la fonction (il s’agit d’un décorateur de fonction Python). Les chemins peuvent contenir des paramètres (indiqués entre chevrons <...>) qui seront passés comme argument à la fonction Python.

La fonction suivante montre un exemple simple de page web avec Flask :

from flask import Flask, url_for  
 
app = Flask(__name__)  
 
@app.route('/chemin/<parametre>')  
def page_web(parametre):  
   html = "<html><body>"  
   html += "La valeur du paramètre est : %s" % paramètre  
   html += "</body></html>"  
   return html 

Le programme complet de notre site web est le suivant :

# Fichier site_dynamique.py  
from owlready2 import *  
onto = get_ontology("bacterie.owl").load()  
 
from flask import Flask, url_for  
app = Flask(__name__)  
 
@app.route('/')  
def page_ontologie():...