Blog

le 25/05/2010
Thomas Bordet
Collaboration, Décisionnel Oracle, Infrastructures, SOA & Urbanisation

Le Moteur Sémantique d'Oracle 11g Release 2

Le web subit, en ce moment même, une transformation de fond : celle de la sémantique. Oracle 11g Release 2 fournit un moteur pour préparer et gérer vos données dans cette perspective. Cela mérite quelques explications…
Les standards HTTP et HTML s’appuient sur Internet pour présenter les données et permettre aux utilisateurs de naviguer dans ces informations par associations grace aux hyperliens. Les moteurs de recherche et les outils web 2.0 ont radicalement transformé vos accès à ces informations. Pourtant, malgré les avancées de l’informatique, 99,999% des machines, ne comprennent toujours rien à ce qu’elles manipulent. De sorte que si vous recherchez "Larry" sur le web, vous tomberez aussi bien sur Larry Ellison, Larry King que Greg "Larry". Si maintenant, vous cherchez Larry Ellison, vous risquez de tomber sur un de ses homonymes ou sur l’interview de Jennifer Aniston par Larry King. Enfin si vous recherchez Larry Ellison Oracle, vos passerez à côté des articles qui mentionnent Lawrence J. Ellison ou négligent qu’il est le patron et principal actionnaire d’Oracle.
Évidemment si les ordinateurs nous comprenaient, ça aiderait beaucoup ! Quoique…
La sémantique fournit des outils pour permettre aux machines de faire le lien entre ce qu’elles manipulent et le « sens » des informations associées. Pour cela, elle s’appuie sur plusieurs principes, outils et standards que je vous laisse découvrir par vous-même. Pour les besoins de cet article, j’en développerai 2 qui sont :

L’utilisation de méta-données, organisées sous la forme de triplets {sujet, prédicat, objet}. Voici 2 exemples de tels triplets :
- {<http://en.wikipedia.org/wiki/Larry_Ellison> <http://dbpedia.org/property/reference> <http://www.oracle.com/people/larry>} signifie que l’article de Wikipedia.fr implique « Larry Ellison ».
- { <http://www.oracle.com/people/larry> rdf:sameAS <http://www.linkedin.com/pub/larry-ellison/3/8ba/42a> } indique que Larry Ellison sur oracle.com est la même personne que Larry Ellison sur LinkedIn.com; ce second triplet utilise la syntaxe RDF permettant la définition de l’identité
La définition de règles d’implications (entailments); ces règles peuvent être inhérentes aux vocabulaires utilisés (RDFS, OWL, SKOS) ou spécifiques

Dans un monde idéal, où toute donnée sera liée, vous retrouverez simplement tous les articles qui référencent « Larry Ellison » patron d’Oracle, tous les films dans lesquels il a joué ou tous les films dans lesquels un patron d’une entreprise du Nasdaq a joué. Le champs des applications est illimité ce qui explique sans doute l’engouement autours des standards (RDF, OWL, SKOS, SPARQL), des outils ou le nombre de recherches et de thèses à propos de la sémantique. L’inventeur du web, Tim Berners Lee (cf sa FOAF Card) est d’ailleurs aujourd’hui le premier vecteur de son développement. Et vous voyez que tout ça arrivera sans que les ordinateurs nous comprennent plus qu’ils ne le font aujourd’hui….

Le moteur sémantique d’Oracle

Maintenant que vous avez touché du doigt les possibilités offertes par la sémantique pour (1) tirer partie des informations existantes et (2) déduire des informations complémentaires à partir de celles existantes, les questions que vous vous posez peut-être sont :

Comment mettre à profit ces concepts sur vos données existantes ?
Comment mettre en œuvre une plateforme pour manipuler ces données en volume, performance et en toute sécurité ?

Le moteur sémantique d’Oracle répond justement à ces questions; en particulier, il :

offre un format adhoc et sécurisé pour stocker les informations sémantiques avec vos autres données; il sert d’infrastructure pivot entre les outils et applications sémantiques,
permet de charger facilement, en masse et rapidement vos données sémantiques,
implémente les différents standards et outils de requêtes des informations sémantiques,
offre des propositions de valeur autour de ces concepts (Virtual Private Database, Intégration aux structures relationnelles et documents, Accès aux data mining, Collaboration, Simulation, …)
propose une intégration « out-of-the-box » aux principaux outils du marché qu’ils soient opensource (Sesame, Pellet, Jena, Gate, Cytoscape, …) ou partenaires (Thomson Reuters, Top Quadrand, Teranode, Ontoprise, Metanomix, …)

Pour cela, le moteur sémantique étend l’infrastructure Network Data Model d’Oracle Spatial et offre des algorithmes et des outils dédiés. Assez disserté, passons à la mise en œuvre…

Exemple « FAMILY » ou le premier modèle sémantique

Pour utiliser le moteur sémantique, il faut commencer par paramétrer votre base de données en conséquence. Vous devrez créer une base de données 11g Release 2 qui inclut les options Spatial, le partitioning et la compression. Dans le script ci-dessous, vous paramètrerez le moteur sémantique, créerez un tablespace dédié (changez le chemin pour qu’il corresponde à votre configuration) et créerez un utilisateur demo qui stockera les données sémantiques :

connect / as sysdba
@?/md/admin/catsem.sql
col namespace format a15
col attribute format a15
col value  format a15
col description  format a60
set lines 120
set pages 1000
select *
  from MDSYS.RDF_PARAMETER
  order by attribute;
create tablespace sem_ts
   datafile '/u01/app/oracle/oradata/BLACK/sem_ts01.dbf'
   size 100M autoextend on
   segment space management auto;
create user demo
   identified by demo
   default tablespace sem_ts
   temporary tablespace temp;
grant connect, resource, dba to demo;

Une fois l’environnement créé, connectez-vous avec l’utilisateur DEMO puis créez:

Un réseau sémantique pour stocker votre modèle
Une table family_rdf_data avec une colonne de type sdo_rdf_triple_s qui stocke les triplets de votre modèle
Un modèle sémantique family qui fait le lien entre la colonne de la table et les structures de stockage du modèle sémantique

connect demo/demo
execute sem_apis.create_sem_network(       -
              tablespace_name => 'sem_ts')
create table family_rdf_data (id number,
                              triple sdo_rdf_triple_s);
execute sem_apis.create_rdf_model(                -
           model_name       => 'family',          -
           table_name       => 'family_rdf_data', -
           column_name      => 'triple');

Vous pouvez ensuite charger l’ensemble des triplets du modèle sémantique disponible sous forme d’ordres INSERT dans la documentation Oracle dans l’exemple 1-20.

Remarque:
Si fa: est l’alias pour "http://www.example.org/family", le triplet : { fa:John fa:fatherOf fa:Suzie } par exemple est assez explicite;
D’autres triplets qui référencent le schéma RDF en revanche permettront de calculer des implications et donc de réaliser des requêtes avec inférences. Il s’agit par exemple de {fa:fatherOf rdfs:domain fa:Male} qui signifie littéralement que si quelqu’un est fa:fatherOf alors, il est aussi fa:Male

Premières requêtes sémantiques

La fonction de table SEM_MATCH permet d’exécuter des requêtes sémantiques en utilisant une syntaxe semblable à SPARQL; par exemple, voici comment interroger le modèle family et rechercher l’ensemble des personnes de sexe masculin:

SELECT m
  FROM TABLE(SEM_MATCH(
    '{?m rdf:type fa:Male}',
    SEM_Models('family'),
    null,
    SEM_ALIASES(SEM_ALIAS('fa','http://www.example.org/family/')),
    null));
M
----------------------------------
http://www.example.org/family/Jack
http://www.example.org/family/Tom

Vous noterez que dans le cas de cette requête, seules 2 personnes sont de sexe masculin; la raison est que nous n’avons pas intégré les inférences liées au vocabulaire RDFS. Pour réaliser l’implication entre "fa:fatherOf" et "fa:Male", il faut créer l’index d’implication (entailment) correspondant à l’aide de la commande ci-dessous :

exec sem_apis.create_entailment(                           -
        index_name_in => 'family_ix',          -
        models_in     => sem_models('family'), -
        rulebases_in  => sem_rulebases('RDFS'))

Une fois l’index créé, vous pouvez ajouter la règle d’inférence à votre requête SEM_MATCH comme ci-dessous :

SELECT m
  FROM TABLE(SEM_MATCH(
    '{?m rdf:type fa:Male}',
    SEM_Models('family'),
    sem_rulebases('RDFS'),
    SEM_ALIASES(SEM_ALIAS('fa','http://www.example.org/family/')),
    null));
M
-----------------------------------
http://www.example.org/family/Jack
http://www.example.org/family/Tom
http://www.example.org/family/John
http://www.example.org/family/Sammy
http://www.example.org/family/Matt

Règles d’Implications Personnalisées

Il est possible de créer ses propres règles d’implications. L’API sem_apis.create_rulebase permet de créer une base de règles que vous alimenterez ensuite avec des commandes INSERT comme ci-dessous :

execute sem_apis.create_rulebase('family_rb');
INSERT INTO mdsys.semr_family_rb(rule_name, antecedents, filter, consequents, aliases)
 VALUES('grandparent_rule', '(?x X:parentOf ?y) (?y X:parentOf ?z)', null, '(?x X:grandParentOf ?z)',
        sem_aliases(sem_alias('X','http://www.example.org/family/'))
       );
commit;
select * from mdsys.semr_family_rb;

Dans cet exemple, le couple (antécédents, conséquents) indique que si x est un parent de y qui est un parent de z, alors x est un grand parent de z. On peut alors créer un index d’implications comme dans l’exemple précédent mais avec des règles définies par l’utilisateur :

exec sem_apis.create_entailment(                           -
        index_name_in => 'family_rb_family_ix',            -
        models_in     => sem_models('family'),             -
        rulebases_in  => sem_rulebases('RDFS','family_rb'),-
        options       => 'USER_RULES=T')

On peut ensuite exécuter des requêtes sémantiques qui prennent en compte la base de règles utilisateur pour savoir, par exemple qui est le grand-père de Tom:

SELECT x
  FROM TABLE(SEM_MATCH(
    '{?x fa:grandParentOf fa:Tom . ?x rdfs:type fa:Male}',
    SEM_Models('family'),
    SEM_Rulebases('RDFS','family_rb'),
    SEM_ALIASES(SEM_ALIAS('fa','http://www.example.org/family/'),
                SEM_ALIAS('rdfs','http://www.w3.org/1999/02/22-rdf-syntax-ns#')),
    null));
X
-------------------------------------
http://www.example.org/family/John

Supprimer le modèle

Pour supprimer votre modèle sémantique, supprimez les index, le modèle, la base de règle, la table et le réseau; vous pourrez ainsi supprimer l’utilisateur et le tablespace associé :

exec sem_apis.drop_entailment(            -
        index_name_in => 'family_rb_family_ix')
exec sem_apis.drop_entailment(            -
        index_name_in => 'family_ix')
execute sem_apis.drop_rdf_model(model_name => 'family')
execute sem_apis.drop_rulebase('family_rb')
drop table family_rdf_data purge;
execute sem_apis.drop_sem_network(true)
connect / as sysdba
drop user demo cascade;
drop tablespace sem_ts including contents and datafiles;

Un dernier mot

Cet article n’est qu’une toute petite introduction au moteur sémantique d’Oracle 11g Release 2. Je souhaite qu’il vous permette de partager mon enthousiasme. Pour en savoir plus, lisez la documentation, plongez dans tous les standards attenant et découvrez les nombreux produits et frameworks associés. Par ailleurs, concernant encore le moteur sémantique d’Oracle, vous trouverez 2 autres articles en français à propos des plug-ins fournies par Oracle pour les logiciels open-sources Cytoscape et Jena. N’hésitez pas à partager vos expériences avec la sémantique et Oracle en commentant cet article. Enjoy!