Web sémantique et ontologies Les API de développement d’applications pour les ontologies (en java) Jena (1ère API développée, très utilisée) OWL API (2ème API pour OWL 2, plus récente) Les API permettent de créer et visualiser des ontologies Et faire des raisonnements et des interrogations Systèmes Intelligents – M2- BD-IA

Systèmes Intelligents – M2- BD-IA Jena Jena est un environnement qui permet le développement d’applications pour le web sémantique. Il inclut : Des API pour les modèle RDF, RDFS et OWL Des outils pour gérer la persistance des données (avec des bases de données) Des outils pour gérer des requêtes SPARQL Jena est un logiciel « Open source » développé par « HP Labs Semantic Research » http://www.hpl.hp.com/semweb/ Systèmes Intelligents – M2- BD-IA

Exemple d’ontologie personName Person age email Professor Student studentNumber taughtBy teach enrolledIn Module moduleName Diploma hasModule diplomaName

<rdf:RDF ...> <owl:Ontology rdf:about=""/> <owl:DatatypeProperty rdf:ID="age"> <rdfs:domain rdf:resource="#Person"/> <rdfs:range rdf:resource="&xsd;int"/> </owl:DatatypeProperty> <owl:Class rdf:ID="Diploma"/> <owl:DatatypeProperty rdf:ID="diplomaName"> <rdf:type rdf:resource="&owl;FunctionalProperty"/> <rdfs:domain rdf:resource="#Diploma"/> <rdfs:range rdf:resource="&xsd;string"/> <owl:DatatypeProperty rdf:ID="email"> <owl:ObjectProperty rdf:ID="enrolledIn"> <rdfs:domain rdf:resource="#Student"/> <rdfs:range rdf:resource="#Diploma"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="hasModule"> <rdfs:range rdf:resource="#Module"/> <owl:Class rdf:ID="Module"/> <owl:DatatypeProperty rdf:ID="moduleName"> <rdfs:domain rdf:resource="#Module"/> <owl:Class rdf:ID="Person"/> <owl:DatatypeProperty rdf:ID="personName"> <rdfs:domain rdf:resource="#Person"/> <rdfs:range rdf:resource=“&xsd;string"/> </owl:DatatypeProperty> <owl:Class rdf:ID="Professor"> <rdfs:subClassOf rdf:resource="#Person"/> </owl:Class> <owl:Class rdf:ID="Student"> <owl:DatatypeProperty rdf:ID="studentNumber"> <rdf:type rdf:resource=“&owl;FunctionalProperty"/> <rdfs:domain rdf:resource="#Student"/> <owl:ObjectProperty rdf:ID="taughtBy"> <rdfs:domain rdf:resource="#Module"/> <rdfs:range rdf:resource="#Professor"/> <owl:inverseOf rdf:resource="#teach"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="teach"> <rdfs:domain rdf:resource="#Professor"/> <rdfs:range rdf:resource="#Module"/> <owl:inverseOf rdf:resource="#taughtBy"/> </rdf:RDF>

Jena : Panorama « Jena 2 Ontology API » L’API Jena fournit un ensemble de classes java dédiées à la manipulation d’ontologies décrites en OWL Ces classes permettent de La gestion d’un modèle (OntModel) La gestion de « documents » (OntDocumentManager) La gestion des classes de l’ontologie OntRessource (classe racine) OntClass (classes de l’ontologies) La gestion des propriétés (OntProperty) La gestion des classes anonymes (Restriction) Les instances (Individuals) Les méta-données (Ontology) Systèmes Intelligents – M2- BD-IA

Jena : Panorama « Jena 2 Ontology API » Le moteur d’inférence Jena Diverses capacités de raisonnement Possibilité de ne pas utiliser ces capacités La persistance des ontologies Stockage en base des informations Systèmes Intelligents – M2- BD-IA

Jena : Panorama « Jena 2 Ontology API » Un modèle d’ontologie (OntModel) est une extension de modèle Jena RDF. Il peut être créé à l’aide la classe ModelFactory Il est possible de spécifier le langage, le mode stockage et le mode d’inférence Par défaut : OWL Full, stockage en mémoire et inférence de type « RDFS » i.e. classification hiérarchique des concepts Systèmes Intelligents – M2- BD-IA

Packages jena à importer import com.hp.hpl.jena.ontology.*; import com.hp.hpl.jena.ontology.impl.*; import com.hp.hpl.jena.rdf.model.*;

Création d’un modèle d’ontologie OntModel m = ModelFactory.createOntologyModel(); Paramétrage par défaut : Langage OWL-Full Stockage in-memory RDFS inférence Autre paramétrage Langage OWL-DL Pas d’inférence

OntModel m = ModelFactory. createOntologyModel(OntModelSpec OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM); OntModelSpec Language profile Storage model Reasoner OWL_MEM OWL full in-memory none OWL_MEM_TRANS_INF transitive class-hierarchy inference OWL_MEM_RULE_INF rule-based reasoner with OWL rules OWL_MEM_MICRO_RULE_INF optimised rule-based reasoner with OWL rules OWL_MEM_MINI_RULE_INF rule-based reasoner with subset of OWL rules OWL_DL_MEM OWL DL OWL_DL_MEM_RDFS_INF rule reasoner with RDFS-level entailment-rules OWL_DL_MEM_TRANS_INF OWL_DL_MEM_RULE_INF OWL_LITE_MEM OWL Lite OWL_LITE_MEM_TRANS_INF OWL_LITE_MEM_RDFS_INF OWL_LITE_MEM_RULES_INF DAML_MEM DAML+OIL DAML_MEM_TRANS_INF DAML_MEM_RDFS_INF DAML_MEM_RULE_INF rule-based reasoner with DAML rules RDFS_MEM RDFS RDFS_MEM_TRANS_INF RDFS_MEM_RDFS_INF

Lecture d’un fichier OWL dans un modèle String fileName = "../university.owl "; try { File file = new File(fileName); FileReader reader = new FileReader(file); OntModel model = ModelFactory .createOntologyModel(OntModelSpec.OWL_DL_MEM); model.read(reader,null); } catch (Exception e) { e.printStackTrace(); }

Liste de toutes les classes de l’ontologie Iterator classIter = model.listClasses(); while (classIter.hasNext()) { OntClass ontClass = (OntClass) classIter.next(); String uri = ontClass.getURI(); if(uri != null) System.out.println(uri); } Il est possible d’utiliser ontClass.getLocalName() pour avoir le nom de la classe. Si la classe n’a pas de nom (e.g. une classe de restriction) alors ontClass.getURI() retourne null. Class: Professor Class: Module Class: Student Class: Person Class: Diploma output

Récupérer une classe particulière Une classe spécifique est identifiée par son URI. String classUri = "http://www.owl-ontologies.com/Ontology1231405083.owl#Professor"; OntClass professor = model.getOntClass(classUri); // ... Si on connaît seulement le nom de la classe (sans son URI complète), on peut obtenir l’URI complète en concaténant l’URI de l’ontologie avec le nom de la classe: ClassURI = OntologyURI + ‘#’ + ClassName

Connaître l’URI d’une ontologie Iterator iter = model.listOntologies(); if(iter.hasNext()){ String Ontologyuri = ((OntologyImpl) iter.next()).getURI(); System.out.println("Ontology URI = "+uri); } Ensuite construction du nom de la classe : String classUri = uri + "#Professor"; OntClass professor = model.getOntClass(classUri); // ...

Hiérarchie des classes Pour connaître la sous-classe et la sur-classe d’une classe donnée (ici : Student et Person) OntClass student = model.getOntClass(uri+"#Student"); System.out.println(student.getSuperClass()); System.out.println(student.getSubClass()); http://www.owl-ontologies.com/Ontology1231405083.owl#Person null OntClass person = model.getOntClass(uri+"#Person"); System.out.println(person.getSuperClass()); System.out.println(person.getSubClass()); null http://www.owl-ontologies.com/Ontology1231405083.owl#Professor

Hiérarchie des classes Pour connaître les sous-classes et les sur-classes d’une classe Iterator supIter = person.listSuperClasses(); while (supIter.hasNext()) { OntClass sup = (OntClass) supIter.next(); System.out.println(sup); } System.out.println("----------------"); Iterator subIter = person.listSubClasses(); while (subIter.hasNext()) { OntClass sub = (OntClass) subIter.next(); System.out.println(sub); ---------------- http://www.owl-ontologies.com/Ontology1231405083.owl#Professor http://www.owl-ontologies.com/Ontology1231405083.owl#Student

Hiérarchie des classes true : direct sub-classes listSubClasses(boolean) false : all sub-classes (sub-sub-classes…) (default) true : direct super-classes listSuperClasses(boolean) false : all super-classes (super-super-classes…) (default) A A.listSubClasses(true) -> B, C A.listSubClasses(false) -> B, C, D B C D.listSuperClasses(true) -> C D.listSuperClasses(false) -> C, A D

Hiérarchie des classes <OntClass>.isHierarchyRoot() Cette méthode retourne vrai si la classe est à la racine de la hiérarchie dans le modèle i.e. La classe a “owl:Thing” comme super-classe directe, ou n’a pas de super-classe owl:Thing Professor Module Diploma Person Student

Liste des propriétés d’une classe OntClass student = model.getOntClass(uri+"#Student"); Iterator propIter = student.listDeclaredProperties(); while (propIter.hasNext()) { OntProperty property = (OntProperty) propIter.next(); System.out.println("property: "+ property.getLocalName()); } output property: studentNumber property: age property: personName property: enrolledIn property: email true : directly associated properties listDeclaredProperties(boolean); false : all properties (direct + inherited) (default)

Connaître le type d’une propriété Il existe deux façons de savoir si une propriété est de type « datatype property » ou « object property » : 1ère solution : 1 if(property.isObjectProperty()){ // ... this is an object property } else if (property.isDatatypeProperty()){ // ... this is an datatype property } property.isFunctionalProperty(); property.isSymmetricProperty(); property.isTransitiveProperty(); property.isInverseOf(property);

Connaître le type d’une propriété 2ème solution : Resource propertyType = property.getRDFType(); System.out.println(propertyType); if(propertyType.equals(OWL.DatatypeProperty)){ // ... this is an datatype property } else if(propertyType.equals(OWL.ObjectProperty)){ // ... this is an object property } 2 http://www.w3.org/2002/07/owl#DatatypeProperty http://www.w3.org/2002/07/owl#ObjectProperty output

Domaine de départ et d’arrivée d’une propriétés String propertyName = property.getLocalName(); String dom = ""; String rng = ""; if(property.getDomain()!=null) dom = property.getDomain().getLocalName(); if(property.getRange()!=null) rng = property.getRange().getLocalName(); System.out.println(propertyName +": \t("+dom+") \t -> ("+rng+") "); listDeclaredProperties(boolean); output true studentNumber: (Student) -> (string) enrolledIn: (Student) -> (Diploma) studentNumber: (Student) -> (string) age: (Person) -> (int) personName: (Person) -> (string) enrolledIn: (Student) -> (Diploma) email: (Person) -> (string) false

Liste des propriétés “Datatype” Iterator iter = model.listDatatypeProperties(); while (iter.hasNext()) { DatatypeProperty prop = (DatatypeProperty) iter.next(); String propName = prop.getLocalName(); String dom = ""; String rng = ""; if(prop.getDomain()!=null) dom = prop.getDomain().getLocalName(); if(prop.getRange()!=null) rng = prop.getRange().getLocalName(); System.out.println(propName +": \t("+dom+") \t -> ("+rng+") "); } output diplomaName: (Diploma) -> (string) studentNumber: (Student) -> (string) moduleName: (Module) -> (string) age: (Person) -> (int) personName: (Person) -> (string) email: (Person) -> (string)

Liste des propriétés “Object” Iterator iter = model.listObjectProperties(); while (iter.hasNext()) { ObjectProperty prop = (ObjectProperty) iter.next(); String propName = prop.getLocalName(); String dom = ""; String rng = ""; if(prop.getDomain()!=null) dom = prop.getDomain().getLocalName(); if(prop.getRange()!=null) rng = prop.getRange().getLocalName(); System.out.println(propName +": \t("+dom+") \t -> ("+rng+") "); } output enrolledIn: (Student) -> (Diploma) hasModule: (Diploma) -> (Module) taughtBy: (Module) -> (Professor) teach: (Professor) -> (Module) getInverse() → (OntProperty)

Autres caractéristiques des propriétés Liste des propriétés fonctionnelles, inverse fonctionnelles, symétriques, transitives model.listFunctionalProperties() model.listInverseFunctionalProperties() model.listSymmetricProperties() model.listTransitiveProperties()

Union Intersection Complément Il est aussi possible de connaître les classes définies à l’aide des opérateurs ensemblistes (union, intersection et complément) Récupération de la liste des « opérandes » Systèmes Intelligents – M2- BD-IA

Union Intersection Complément if(ontClass.isIntersectionClass()){ IntersectionClass intersection = ontClass.asIntersectionClass(); RDFList operands = intersection.getOperands(); for (int i = 0; i < operands.size(); i++) { RDFNode rdfNode = operands.get(i); ... } } else if(ontClass.isUnionClass()){ UnionClass union = ontClass.asUnionClass(); RDFList operands = union.getOperands(); } else if(ontClass.isComplementClass()){ ComplementClass compl = ontClass.asComplementClass(); RDFList operands = compl.getOperands();

Systèmes Intelligents – M2- BD-IA Restrictions Il est également possible de connaître les classes définies à l’aide de restrictions SomeValueFrom, AllValuesFrom, HasValue if(ontClass.isRestriction()){ Restriction rest = ontClass.asRestriction(); OntProperty onProperty = rest.getOnProperty(); ... } Systèmes Intelligents – M2- BD-IA

AllValuesFrom / SomeValuesFrom if(rest.isAllValuesFromRestriction()){ AllValuesFromRestriction avfr = rest.asAllValuesFromRestriction(); Resource avf = avfr.getAllValuesFrom(); ... } if(rest.isSomeValuesFromRestriction()){ SomeValuesFromRestriction svfr = rest.asSomeValuesFromRestriction(); Resource svf = svfr.getSomeValuesFrom();

HasValue if(rest.isHasValueRestriction()){ HasValueRestriction hvr = rest.asHasValueRestriction(); RDFNode hv = hvr.getHasValue(); ... }

Restrictions sur les cardinalités MinCardinality / MaxCardinality if(rest.isCardinalityRestriction()){ CardinalityRestriction cr = rest.asCardinalityRestriction(); int card = cr.getCardinality(); ... } if(rest.isMinCardinalityRestriction()){ MinCardinalityRestriction mcr = rest.asMinCardinalityRestriction(); int minCard = minCR.getMinCardinality(); if(rest.isMaxCardinalityRestriction()){ MaxCardinalityRestriction mcr = rest.asMaxCardinalityRestriction(); int maxCard = maxCR.getMaxCardinality();

Instances des classes Liste de toutes les intances Iterator individuals = model.listIndividuals(); while (individuals.hasNext()) { Individual individual = (Individual) individuals.next(); ... } Liste des instances d’une classe Iterator iter = ontClass.listInstances(); while (iter.hasNext()) { Individual individual = (Individual) iter.next(); ... }

Instances des propriétés Liste des propriétés (et valeurs) pour une instance Iterator props = individual.listProperties(); while (props.hasNext()) { Property property = (Property) props.next(); RDFNode value = individual.getPropertyValue(property); ... } Liste des valeurs des propriétés pour une instance Iterator values = individual.listPropertyValues(property); while (values.hasNext()) { RDFNode value = values.next(); ... }

Instances Connaître la classe d’une instance Resource rdfType = individual.getRDFType(); OntClass ontClass = model.getOntClass(rdfType.getURI()); Autre forme, dans les versions récentes de Jena OntClass ontClass = individual.getOntClass();

Création d’une ontologie

Création du modèle de l’ontologie Création de l’ontologie en spécifiant son URI OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM); String uriBase = "http://www.something.com/myontology"; model.createOntology(uriBase);

Spécification des sous-classes Création des classes //create classes OntClass person = model.createClass(uriBase+"#Person"); OntClass module = model.createClass(uriBase+"#Module"); OntClass diploma = model.createClass(uriBase+"#Diploma"); OntClass student = model.createClass(uriBase+"#Student"); OntClass professor = model.createClass(uriBase+"#Professor"); Spécification des sous-classes //set sub-classes person.addSubClass(student); person.addSubClass(professor);

Création des propriétés de type “Datatype” //create datatype properties DatatypeProperty personName = model.createDatatypeProperty(uriBase+"#personName"); personName.setDomain(person); personName.setRange(XSD.xstring); DatatypeProperty age = model.createDatatypeProperty(uriBase+"#age"); age.setDomain(person); age.setRange(XSD.integer); // ... ...

Création des propriétés “Object” //create object properties ObjectProperty teach = model.createObjectProperty(uriBase+"#teach"); teach.setDomain(professor); teach.setRange(module); ObjectProperty taughtBy = model.createObjectProperty(uriBase+"#taughtBy"); taughtBy.setDomain(module); taughtBy.setRange(professor); ObjectProperty enrolledIn = model.createObjectProperty(uriBase+"#enrolledIn"); enrolledIn.setDomain(student); enrolledIn.setRange(diploma); // ... ...

Spécification des propriétés inverses // set inverse properties teach.setInverseOf(taughtBy); Spécification des propriétés fonctionnelles // set functional properties enrolledIn.setRDFType(OWL.FunctionalProperty);

Spécification de restrictions usually, null usually, a class SomeValuesFromRestriction svfr = model.createSomeValuesFromRestriction(uri, property, resource); AllValuesFromRestriction avfr = model.createAllValuesFromRestriction(uri, property, resource); HasValueRestriction hvr = model.createHasValueRestriction(uri, property, rdfNode); CardinalityRestriction cr = model.createCardinalityRestriction(uri, property, int); MinCardinalityRestriction min_cr = model.createMinCardinalityRestriction(uri, property, int); MaxCardinalityRestriction max_cr = model.createMaxCardinalityRestriction(uri, property, int);

Intersection / Union / Complement RDFNode[] classes = new RDFNode[] {class1, class2, ...}; RDFList list = model.createList(classes); IntersectionClass intersection = model.createIntersectionClass(uri, list); UnionClass union = model.createUnionClass(uri, list); ComplementClass compl = model.createComplementClass(uri,resource);

Instances Création d’une instance (individual) ou Individual indv = ontClass.createIndividual(uri); ou Individual indv = model.createIndividual(uri, ontClass); Création d’une instance de propriétés pour un individu. indv.setPropertyValue(property, rdfNode);

Ecriture du modèle sur une sortie standard model.write(System.out,"RDF/XML-ABBREV"); Ecriture du modèle dans une chaîne StringWriter sw = new StringWriter(); model.write(sw, "RDF/XML-ABBREV"); String owlCode = sw.toString(); Ecriture du modèle dans un fichier File file = new File(filePath); try{ FileWriter fw = new FileWriter(file); fw.write(owlCode); fw.close(); } catch(FileNotFoundException fnfe){ fnfe.printStackTrace(); } catch(IOException ioe){ ioe.printStackTrace(); }

Jena : Panorama « Jena 2 Ontology API » Bilan Jena propose une API très complète pour manipuler des ontologies et permet le développement d’applications ayant besoin d’accéder aux informations d’une ontologie (et de la mettre à jour). Cet environnement de développement est très utilisé. Il est adapté aux langages de la pyramide du Web (RDF, RDFS, OWL). Jena permet aussi de travailler sur des requêtes exprimées en SPARQL http://jena.sourceforge.net/ontology/index.html Systèmes Intelligents – M2- BD-IA

Systèmes Intelligents – M2- BD-IA OWL API http://semanticweb.org/wiki/OWL_API http://owlapi.sourceforge.net/ L’API OWL est définie pour travailler sur les spécifications de OWL 2 Dans l’API OWL, une ontologie (OWLOntology) comporte Un nom (IRI, Un ensemble d’axiomes logiques et non logiques Des méthodes pour accéder à ces axiomes Systèmes Intelligents – M2- BD-IA

OWL API : Axiomes, Entités, Classes, Propriétés, Individus Une entité (OWLEntity) est définie par une IRI Noms des classes, propriétés de données ou objet, individus La classe OWLClassExpression représente des expressions de classes comme les restrictions (classes anonymes) OWLPropertyExpression représente des expressions de propriétés comme les propriétés inverses. Systèmes Intelligents – M2- BD-IA

OWL API : Axiomes, Entités, Classes, Propriétés, Individus La classe OWLAxiom modélise Les axiomes sur les classes (subsumption, disjonction, équivalence) -> TBox Les axiomes sur les individus (assertions) -> ABox Les axiomes sur les propriétés (relations entre les propriétés) -> RBox Systèmes Intelligents – M2- BD-IA

OWL API – Exemple Chargement d’une ontologie File file = new File("pizza.owl"); OWLOntologyManager man = OWLManager.createOWLOntologyManager(); OWLOntology ont = man.loadOntologyFromOntologyDocument( IRI.create(file)); Systèmes Intelligents – M2- BD-IA

OWL API – Exemple Visualisation des classes Utilisation de la méthode « getClassesInSignature » qui retourne l’ensemble des classes de l’ontologie Set<OWLClass> tmp = ont.getClassesInSignature(); for (OWLClass cls : tmp) System.out.println(cls.getIRI().getShortForm()); getShortForm permet de n’afficher que le nom de la classe pas son IRI complète Systèmes Intelligents – M2- BD-IA

OWL API – Exemple Visualisation des propriétés objet Set<OWLObjectProperty> tmp = ont.getObjectPropertiesInSignature(); for (OWLObjectProperty op : tmp) { s = ">>>>>> " + op.getIRI().getShortForm() + " <<<<<\n"; for (OWLObjectPropertyDomainAxiom dom : ont.getObjectPropertyDomainAxioms(op)) { s += "Domain : " + dom.getDomain().asOWLClass().getIRI().getShortForm() + "\n"; } for (OWLObjectPropertyRangeAxiom ran : ont.getObjectPropertyRangeAxioms(op)) { s += "Range : " + ran.getRange().asOWLClass().getIRI().getShortForm() + "\n"; } } // attention asOWLClass -> ok si classe nommée simple Systèmes Intelligents – M2- BD-IA

OWL API – Exemple Visualisation des propriétés de données Set<OWLDataProperty> tmp = ont.getDataPropertiesInSignature(); for (OWLObjectProperty op : tmp) { s = ">>>>>> " + op.getIRI().getShortForm() + " <<<<<\n"; for (OWLDataPropertyDomainAxiom dom : ont.getDataPropertyDomainAxioms(op)) { s += "Domain : " + dom.getDomain().asOWLClass().getIRI().getShortForm() + "\n"; } for (OWLDataPropertyRangeAxiom ran : ont.getDataPropertyRangeAxioms(op)) { s += "Range : " + ran.getRange().toString() + "\n"; } } // attention asOWLClass -> ok si classe nommée simple Systèmes Intelligents – M2- BD-IA

OWL API – Exemple Visualisation des individus Set< OWLNamedIndividual > tmp= ont.getIndividualsInSignature(); for (OWLNamedIndividual ind : tmp) { for (OWLClassAssertionAxiom classAssert : ont.getClassAssertionAxioms(ind)) System.out.println(classAssert.getIndividual() .asOWLNamedIndividual().getIRI().getShortForm()); } Systèmes Intelligents – M2- BD-IA

Systèmes Intelligents – M2- BD-IA OWL API OWL API comporte toutes les méthodes nécessaires pour gérer (créer, modifier, visualiser) des ontologies en OWL 2 Elle comporte également des outils Pour gérer des règles SWRL, Pour raisonner, Pour interroger (en utilisant jena - SPARQL) Systèmes Intelligents – M2- BD-IA