Personal tools
You are here: Home Ressources Ontologies
Document Actions

Ontologies

by François Rioult last modified 2008-11-06 16:35

Notes sur les ontologies et OWL

  • bons slides
  • OWL Full permet de raisonner sur des classes et des propriétés (une classe est instance de meta-classe)
  • OWL Concrete Abstract Syntax http://owl.man.ac.uk/2003/concrete/latest/

  • une ontologie en ligne de références sur l'engineering http://www.aifb.uni-karlsruhe.de/WBS/cte/ontologyengineering/
  • démonstration en ligne de l'agent de vins : on choisit un plat et le système propose un vin à l'aide d'une ontologie.
  • le guide de référence OWL : http://www.w3.org/TR/owl-guide/ (index, référence, très bien).
  • transparents d'Amedeo Napoli, plein de définitions formelles, fort lien avec DL : http://cdsweb.u-strasbg.fr/MDA/mda/aci-mda-030205.pdf
  • article avec exemple immobilier et quelques détails sur le raisonnement :
    Il est également possible de raisonner sur les ontologies en utilisant un moteur d’inférence général tel que JESS (moteur d'inférence pour java), ou des outils d’inférence spécifiques au web sémantique basés sur des logiques de description [DL], comme TBox et ABox, tels que RACER (contient une GUI).
  • très bons slides sur le raisonnement en logique de description http://www.kde.cs.uni-kassel.de/conf/iccs05/horrocks_iccs05.pdf
  • beaucoup de ressources sur http://www.lespetitescases.net/definir-une-ontologie-avec-owl
  • Introduction à OWL, un langage XML d'ontologies Web
  • page de Christine Porquet : http://www.greyc.ensicaen.fr/~chris/WS_liens_utiles.html
  • traductions en Français du W3C http://www.yoyodesign.org/doc/w3c/index.php
  • bon article sur le tutoriel de protégé en français http://www.bnf.fr/pages/infopro/normes/pdf/no-DevOnto.pdf, mais date un peu (ancien version de Protégé) et présente les classes comme celles des objets.
  • http://rc23.overture.com/d/sr/?xargs=15KPjg1nZSt5auwuf0L%5FiXEbqUkwwB5%2Dm9g84bDOR9HNZY8wYeUvYuPa7By%5FVIX
    %2D1mnQ7VzoOV9K8fOqz2kPyUEAqGW1KIEP3%2D2Y3SnN8wafHlBo0Y0Op51ry2298SYCoQMzuzGeKOoLjBI8CoaHMTodBAm
    EjCkrkznaDgh4hdReuaiwoqpBS70ag077Z4xcHLP8tRR7RDLoOUkDDEfcQEj5x%5Fj%5FLjeWcMdGn7%2DjlOtRTTZi8A1tauY%2Dx
    V4OGk2ZDsMIyHw5sHNFrToKJ1uROX6E6t
  • rechercher ontologie fouille sur hooseek
  • critique des ontologies : http://www.elanceur.org/Articles/OntologieSurfaite.html

Vocabulaire

  • TBox : le schéma (terminologie)
  • ABox : les données (assertions)


Visualisation d'ontologie :


SWOOP

  • C'est vraiment mieux que Protégé 3&4 : explication des inférences. Interface rudimentaire pour développer sérieusement.
  • Problèmes pour exporter
  • démarrer depuis le répertoire courant
  • un code très clair à la création d'un fichier
  • les labels servent de commentaires à la création de l'ontologie, des classes, etc.
  • défaut : l'accès à Pellet pour les requêtes SPARQL ne tolère que ABox.

Racer

  • id de téléchargement : 2gdah4.g37ovb
  • ./RacerPro -http 3491
  • essayé par HTTP dans Protégé3 : n'a pas l'air de mieux fonctionner que Fact++

AllegroGraph

travaille avec Racer


Pellet

  • dans README.txt : Pellet provides functionality to validate ontology species, check consistency of ontologies, classify the taxonomy, check entailments and answer SPARQL queries.
-> n'infère pas les propriétés (retire même celles qui sont assertées), n'effectue que la classification (bon ok, correctement même)
time -p java -jar /data/frt/software/pellet-1.5.2/lib/pellet.jar -if dotaClean.owl -s on -c RDF -cout dotaPellet.owl -r
  • Realization

    Finds the most specific classes that an individual belongs to; i.e., realization computes the direct types for each of the individuals. Realization can only be performed after classification since direct types are defined with respect to a class hierarchy. Using the classification hierarchy, it is also possible to get all the types for each individual.
    Il semble qu'il faille procéder en deux temps : classifier d'abord, puis calculer les instances.

  • pronto ne fonctionne pas
  • pour compiler Pellet, exécuter ant (voire ant dist et pas ant build) -> création du dossier dist, puis exécution dans dist/lib/pellet.jar
  • The command-line Pellet uses the Pellet-Jena interface. Jena does not 
    have any special support for OWL 1.1 or OWL2 yet and Pellet-Jena
    interface simply processes the RDF triples that correspond to OWL 1.1
    serialization. Pellet-OWLAPI interface on the other hand processes
    OWLAPI axioms and OWLAPI handles both OWL 1.1 and OWL2 serializations.
    Since Protege4 uses Pellet-OWLAPI interface you can reason with OWL2
    ontologies through Protege4 without problems. If you write a simplified
    version of Pellet command-line program using OWLAPI then that program
    would also work with OWL2 ontologies.



OWLgres

  • installer postgres, créer une base 'owlgres' maintenue par 'frioult'
  • installer le connecteur java dans le lib de owlgres : mv ~/Desktop/postgresql-8.3-603.jdbc4.jar lib/
  • modifier : echo $OWLGRESROOT
  • sh/create --db owlgres --user frioult --passwd ... --tbox data/dbpedia_tbox_sample.rdf
  • sh/load --db owlgres --user frioult --passwd ... --abox data/dbpedia_abox_sample.rdf
  • sh/load --db owlgres --user frioult --passwd ... --query data/dbpedia_quer
  • sh/query --db owlgres --user frioult --passwd ... --query data/dbpedia_query1.rq
  • sh/query --db owlgres --user frioult --passwd ... --query data/dbpedia_query2.rq
  • sh/query --db owlgres --user frioult --passwd ... --query data/dbpedia_query3.rq |more
  • sh/query --db owlgres --user frioult --passwd ... --query data/dbpedia_query4.rq |more
  • sh/query --db owlgres --user frioult --passwd ... --query data/dbpedia_query5.rq |more

Jess

OWL inference engine using XSLT and JESS : http://www.cs.cmu.edu/~sadeh/MyCampusMirror/OWLEngine.html



Fowl

à essayer, beaucoup de liens sous google
  • installer xsb en étant root
  • installer flora2 en précisant l'adresse de xsb
    ./makeflora all /opt/XSB/bin/xsb
  • je laisse tomber pour la configuration

Fact++

  • ne tolère pas OWL Full, genre équivalence de classe sur assertion d'un data properties d'un type donné
  • il faut émettre au protocole pour avoir le résultat


Ontology based sports video annotation and summary: http://cat.inist.fr/?aModele=afficheN&cpsidt=16367895

OWL n'infère pas de relation quantitative !

OWL makes provision for logical 'qualitative' definition of classes, but definitely not for 'quantitative' definition, like "wheels with diameter over 10". This is not a bug, it's a feature :) . Cardinality is a logical feature, but numerical value of a DatatypeProperty is not one. There are arcane reasons for this dealing with structure of integers vs real numbers. There are some workarounds though. You can define properties minDiameter and maxDiameter and define subclasses of Wheel by hasValue restrictions on those. But this will be only declarative - logical reasoners will not detect any inconsistency if you have set minDiameter to 10 for BigWheel class, and an instance of BigWheel has declared a diameterValue of 9.


SPARQL

  •  conçoit des règles (?) et des requêtes.
  • dans Protégé3 (pas de SPARQL dans Protété4), les requêtes peuvent donner lieu à des annotations de classes, vérifiées lors du test de consistence de l'ontologie.
  • quickReference sur 2 pages : http://www.dajobe.org/2005/04-sparql/SPARQLreference-1.8.pdf
  • beaucoup de ressources : http://www.ibm.com/developerworks/xml/library/j-sparql/
  • Note: You may need to take extra care when working with XML Schema datatypes, because SPARQL maps literals such as "42" or "4.2" with xsd:integer and xsd:double, while most Protégé-OWL ontologies will use xsd:int and xsd:float. As a result, you may need to add the datatype explicitly to match with the query.
  • tutoriel : http://jena.sourceforge.net/ARQ/Tutorial/index.html
http://www.xml.com/pub/a/2005/11/16/introducing-sparql-querying-semantic-web-tutorial.html?page=1


SWRL

  • compatible OWL DL et essayer de s'y restreindre en utilisant des règles DL-safe : For complex reasons (see here, for example), the ability to bind to individuals that are not known causes undecidability. Restricting rules to only bind known individuals has been proven to ensure decidability.
  • le langage des règles pour inférer des propriétés, des classes, ou des requêtes (la prémisse remplace le WHERE), et faire du calcul en récupérant les résultats (pour asserter des propriétés par exemple).
  • intérêt par rapport à DL : on peut inférer des propriétés complexes sans passer par des restrictions de classe. Ex. prop1 ^ prop2 -> prop3, sans être obligé, comme avec DL, de définir une classe comme prop1 ^ prop2, équivalente à prop3
  • question : qu'est-ce que je ne peux pas écrire en DL qui nécessite SWRL ?
  • supports the open world assumption : Publication(?p) ^ hasAuthor(?p, ?y) ^ hasAuthor(?p, ?z) -> collaboratesWith(?y, ?z)
    In formal logic, the open world assumption is the assumption that the truth-value of a statement is independent of whether or not it is known by any single observer or agent to be true. It is the opposite of the closed world assumption which holds that any statement that is not known to be true is false. 
  • on peut définir des built-in (prédicat à un ou deux arguments) et les faire matcher (pour faire des calculs)
    Person(?p) ^ hasAge(?p, ?age) ^ swrlb:greaterThan(?age, 17) -> Adult(?p)
    Rectangle(?r) ^ hasWidthInMeters(?r, ?w) ^ hasHeightInMeters(?r, ?h) ^ swrlb:multiply(?areaInSquareMeters, ?w, ?h) -> hasAreaInSquareMeters(?r, ?areaInSquareMeters)
  • n'implémente pas l'anti-monotonicité : SWRL ne sert qu'à ajouter de la connaissance, pas à en retirer
  • la SWRL Tab permet de rédiger les règles. Si Jess est installé (jess.jar dans le dossier plugins/edu.stanford.smi.protegex.owl/)
    • un SQ (pour SWRL Query) apparaît dans la liste des icones d'édition des règles. Cette table permet d'exécuter des règles dont les conclusions sont des requêtes. Ex. carries(?x, ?z) → sqwrl:select(?x, ?z)
    • un J (pour Jess) : c'est le moteur d'inférence. On commence par copier le contenu de OWL et SWRL dans Jess, puis on l'exécute. Il indique le nombre d'individus inférés (prédicats d'appartenance à une classe), et le nombre d'axioms inférés (propriétés sur des instances). Ces nouvelles informations peuvent être intégrées dans la base OWL.

Fichiers de démarrage

  • Protégé3
    <?xml version="1.0"?>
    <rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:protege="http://protege.stanford.edu/plugins/owl/protege#"
    xmlns:xsp="http://www.owl-ontologies.com/2005/08/07/xsp.owl#"
    xmlns="http://users.info.unicaen.fr/~frioult/ontologie/inference#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:swrl="http://www.w3.org/2003/11/swrl#"
    xmlns:swrlb="http://www.w3.org/2003/11/swrlb#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xml:base="http://users.info.unicaen.fr/~frioult/ontologie/inference">
    <owl:Ontology rdf:about=""/>
    </rdf:RDF>

    <!-- Created with Protege (with OWL Plugin 3.4, Build 506) http://protege.stanford.edu -->
  • Protégé4
    <?xml version="1.0"?>


    <!DOCTYPE rdf:RDF [
    <!ENTITY owl "http://www.w3.org/2002/07/owl#" >
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
    <!ENTITY owl2xml "http://www.w3.org/2006/12/owl2-xml#" >
    <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
    <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
    ]>


    <rdf:RDF xmlns="http://users.info.unicaen.fr/~frioult/ontologie/inference.owl#"
    xml:base="http://users.info.unicaen.fr/~frioult/ontologie/inference.owl"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl2xml="http://www.w3.org/2006/12/owl2-xml#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <owl:Ontology rdf:about=""/>
    </rdf:RDF>
    <!-- Generated by the OWL API (version 2.2.1.842) http://owlapi.sourceforge.net -->
  • Swoop :
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE rdf:RDF [
    <!ENTITY inference "http://users.info.unicaen.fr/~frioult/ontologie/inference.owl">
    <!ENTITY owl "http://www.w3.org/2002/07/owl#">
    <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#">
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">
    ]>
    <rdf:RDF xml:base="&inference;"
    xmlns:owl="&owl;"
    xmlns:rdf="&rdf;"
    xmlns:rdfs="&rdfs;">

    <!-- Ontology Information -->
    <owl:Ontology rdf:about=""
    rdfs:comment="Commentaire"
    rdfs:label="Test d'inférence"
    owl:versionInfo="0.0"/>

    <!-- Annotation Properties -->
    <owl:AnnotationProperty rdf:about="&rdfs;comment"/>
    <owl:AnnotationProperty rdf:about="&rdfs;label"/>
    <owl:AnnotationProperty rdf:about="&owl;versionInfo"/>
    </rdf:RDF>




Protégé

Si Protégé4 est très agréable à utiliser (interface, classification, chaînage arrière), il donne peu d'explication (voire pas du tout) en cas d'inconsistence. Il faut absolument utiliser Protégé3 si l'on veut faire des choses dans le détail. De plus, la version 4 ne fait aucun test sur les domaines et portée des propriétés, ni ne prépare l'interface en conséquence. Elle l'a pas non plus d'interrogation SPARQL ni de moteur de règle SWRL (l'import de ficiers Protégé3 avec des requêtes en SQWRL échoue carrément !).

Protégé4

Protégé4 fait du chaînage arrière avec Pellet pour inférer des propriétés d'objets portant sur des instances, mais ces propriétés ne sont pas sauvegardée (c'est seulement: export infered axioms -> types). Dans Protégé3, si une classe a pour équivalente "property value entity", alors toutes les instances de cette classe ont automatiquement la propriété. L'interface interdit de la supprimer pour une instance.

On peut utiliser Protégé4 pour renommer toutes les URI (refactor/rename entities)


  • tutoriel très complet sur l'exemple pizza http://www.co-ode.org/resources/tutorials/ProtegeOWLTutorial-p4.0.pdf
  • pour l'édition des classes, le tutoriel fait référence à Subclass Of, mais c'est bien SuperClasses qu'il faut utiliser.
  • différence entre FaCT++ et Pellet 1.5 : seul Pellet fait du chaînage arrière pour inférer des propriétés avec les entités. 
  • Protégé utilise SWRL: A Semantic Web Rule Language Combining OWL and RuleML, un mélange entre OWL Lite et DL

Protégé3

Par défaut, contient Pellet mais it is necessary to have a DIG (Description Logic Implementers Group) compliant reasoner installed in order to compute subsumption relationships between classes, and detect inconsistent classes.

  • quand on dit que ClassA est équivalente à hasDataPropertie some int, seules les instances avec une valeur de propriété non nulle seront classées.
  • gros souci avec le type int (préférer integer ?) -> j'utilise les floats
  • les classes définies par des propriétés de données ne sont pas inférées par Fact++.
  • Fact++ n'infère pas les propriétés transitives, comme dans le 4. Pellet les utilise dans Protégé3 pour inférer des classes (infère les propriétés dans Protégé4)

Vocabulaire


Classes

Ce sont plus des conteneurs hiérarchiques que des gabarits champs/méthodes.

  • Pour inférer les types de classe d'une entité, la classe ciblée doit être équivalente à l'expression désirée, puis utiliser le chaînage avant (FaCT++).
  • Pour inférer des propriétés d'objet (on ne peut pas sur les données) sur une entité, définir le type de classe à laquelle elle appartient. Cette classe doit avoir comme superclasse une expression qui utilise la propriété à inférer. On utilise le chaînage arrière : Pellet 1.5

Object Properties

Les classes sont liées entre elles par les relations (object propertie). Une propriété est fonctionnelle si l'antécédent n'a qu'une seule image.
Domain/Range : Properties link individuals from the domain to individuals from the range
It is important to realise that in OWL domains and ranges should not be viewed as constraints to be checked

Although we have specified the domains and ranges of various properties for the
purposes of this tutorial, we generally advise against doing this. The fact that
domain and range conditions do not behave as constraints and the fact that they
can cause ‘unexpected’ classification results can lead problems and unexpected
side effects. These problems and side effects can be particularly difficult to track
down in a large ontology.


Individuals

Ce sont les instances.

Data Properties

Relations entre individuals et valeur de donnée.


On crée une instance et on indique sa classe générale. En précisant propertie assertion/data propertie, on saisit par exemple la valeur d'une propriété. Si une classe est
« June 2011 »
Su Mo Tu We Th Fr Sa
1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30
 

Powered by Plone, the Open Source Content Management System

This site conforms to the following standards: