Santiago Atella Nicolás Genta Diego González INCO - FING - UDELAR

Presentación del tema: "Santiago Atella Nicolás Genta Diego González INCO - FING - UDELAR"— Transcripción de la presentación:

1 Santiago Atella Nicolás Genta Diego González INCO - FING - UDELAR
Tutorial de JENA Santiago Atella Nicolás Genta Diego González INCO - FING - UDELAR

2 JENA Framework desarrollado por HP Labs para manipular metadata desde una aplicación Java. Dos versiones: JENA 1 Principalmente soporte para RDF. Capacidades de razonamiento limitadas. JENA 2 Incluye además una API para el manejo de Ontologias. Soporta el lenguaje OWL.

3 JENA Incluye varios componentes: ARP: Un Parser de RDF. API RDF.
API de Ontologias con soporte para OWL, DAML y RDF Schema. Subsistema de Razonamiento. Soporte para Persistencia. RDQL: Lenguaje de consultas de RDF.

4 RDF Recurso: Propiedad: Literal: Statements:
Todo aquello que se puede describir por una expresión RDF. Propiedad: Una característica, atributo o relación usada para describir un recurso. Literal: Un tipo de datos simple (String, Integer, etc). Statements: Un recurso junto con una propiedad y con un valor asociado.

5 Statements Cada statement tiene tres partes:
Sujeto, Predicado y Objeto. Un modelo RDF es un conjunto de statements.

6 API RDF de Jena Permite crear y manipular modelos RDF desde una aplicación Java. Proporciona clases java para representar: Modelos. Recursos. Propiedades. Literales. Statements.

7 Ejemplo: vcards

8 Crear un modelo RDF String personURI = "http://somewhere/JohnSmith";
String givenName = "John"; String familyName = "Smith"; String fullName = givenName + " " + familyName; Model model = ModelFactory.createDefaultModel(); Resource johnSmith = model.createResource(personURI); johnSmith.addProperty(VCARD.FN, fullName); johnSmith.addProperty(VCARD.N, model.createResource() .addProperty(VCARD.Given, givenName) .addProperty(VCARD.Family, familyName));

9 Escribir y Leer un modelo
Para serializar el modelo a XML: model.write(System.out); Para cargar un modelo en memoria: Model model = ModelFactory.createDefaultModel(); InputStream in = Tutorial05.class.getClassLoader(). getResourceAsStream(ejemplo.owl); model.read(new InputStreamReader(in), "");

10 Navegar un modelo A partir de la URI de un recurso:
// recuperar el recurso John Smith String johnSmithURI = " Resource jSmith = model.getResource(johnSmithURI); // recuperar el valor de la propiedad N Resource name = (Resource) jSmith.getProperty(VCARD.N) .getObject(); // recuperar el valor de la propiedad FN String fullName = (String) jSmith.getProperty(VCARD.FN)

11 Consultar un modelo Buscar información en un modelo:
// recuperar todos los recursos de tipo vcard (asumiendo que // solo ellos tienen la propiedad FN y que todos la tienen) ResIterator it = model.listSubjectsWithProperty(VCARD.FN); while (it.hasNext()) { Resource r = it.nextResource(); System.out.println(r); } Consultas más avanzadas: Utilizar la primitiva listStatements(Selector s). Utilizar el lenguaje de consulta RDQL.

12 Operaciones sobre modelos
Los modelos son conjuntos de statements. Podemos realizar las siguientes operaciones: Unión. Intersección. Diferencia. // leer los modelos de los archivos RDF model1.read(new InputStreamReader(in1), ""); model2.read(new InputStreamReader(in2), ""); // unir los modelos Model model = model1.union(model2);

13 API de Ontologías de Jena
Soporta RDF Schema, DAML y OWL. Es independiente del lenguaje. Los recursos no están ligados estáticamente a una clase java particular. Ejemplo: <owl:Class rdf:ID="DigitalCamera"> </owl:Class> <rdf:type owl:Restriction />

14 API de Ontologías de Jena
Problema: El recurso no cambió, pero la clase Java para modelarlo es otra. No podemos modificar la clase dinamicamente. Jena considera que la abstracción Java del recurso es solo una vista del mismo. Ejemplo: Resource r = model.getResource(myNS + "DigitalCamera"); OntClass c = (OntClass) r.as(OntClass.class); Restriction rest = (Restriction) c.as(Restriction.class);

15 Ejemplo: Ontología de Cámaras

16 Crear un modelo ontológico
Se usa el método createOntologyModel(). Permite especificar: Lenguaje a utilizar. Razonador asociado. String fileName = "c:/ejemplo.owl"; String baseURI = "file:///" + fileName; OntModel model = ModelFactory.createOntologyModel(ProfileRegistry.OWL_DL_LANG); model.read(new FileReader(schemaFileName), baseURI);

17 Clases Son los bloques constructivos básicos.
Se representan con la interfase OntClass. Ejemplo: Obtener las subclases de Camera. <owl:Class rdf:ID="Camera"> <rdfs:subClassOf rdf:resource="#PurchaseableItem"/> </owl:Class> OntClass camera = model.getOntClass(camNS + "Camera"); for (Iterator i = camera.listSubClasses(); i.hasNext();) { OntClass c = (OntClass) i.next(); System.out.println(c.getLocalName()); }

18 Propiedades Se representan mediante la interfase OntProperty.
Ejemplo: Crear las propiedades part y body. OntModel m = ModelFactory.createOntologyModel(); OntClass Camera = m.createClass(camNS + "Camera"); OntClass Body = m.createClass(camNS + "Body"); ObjectProperty part = m.createObjectProperty(camNS + "part"); ObjectProperty body = m.createObjectProperty(camNS + "body"); body.addSuperProperty(part); body.addDomain(Camera); body.addRange(Body);

19 Propiedades DatatypeProperties ObjectProperties
FunctionalProperty TransitiveProperty SymmetricProperty InverseFunctionalProperty Proporciona métodos isXXX para testear el tipo de una propiedad: Ejemplo: isTransitiveProperty()

20 Clases complejas Se pueden definir clases mediante operaciones de unión, intersección y complemento. Ejemplo: <owl:Class rdf:ID="SLR"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Camera"/> <owl:Restriction> <owl:onProperty rdf:resource="#viewFinder"/> <owl:hasValue rdf:resource="#ThroughTheLens"/> </owl:Restriction> </owl:intersectionOf> </owl:Class>

21 // crear la instancia throughTheLens
OntClass Window = m.createClass(camNS + "Window"); Individual throughTheLens = m.createIndividual(camNS + "ThroughTheLens", Window); // crear la propiedad viewfinder ObjectProperty viewfinder = m.createObjectProperty(camNS + "viewfinder"); // crear la restriccion hasValue HasValueRestriction viewThroughLens = m.createHasValueRestriction(null, viewfinder, throughTheLens); // crear la clase Camera OntClass Camera = m.createClass(camNS + "Camera"); // crear la interseccion para definir la clase SLR IntersectionClass SLR = m.createIntersectionClass(camNS + "SLR", m.createList(new RDFNode[] {viewThroughLens, Camera}));

22 Schema vs Instancia Schema Instancia Se puede definir las:
Clases Propiedades (DataTypeProperty, ObjectProperty) Restricciones Tipos de Datos Cardinalidad Instancia Definimos la instancias (individuos) de los elementos del Schema.

23 <owl:Class rdf:ID="Camera">
<rdfs:subClassOf rdf:resource="#Item"/> </owl:Class> <owl:DatatypeProperty rdf:ID="name"> <rdfs:domain rdf:resource="#Camera"/> <rdfs:range rdf:resource=“xsd:string"/> </owl:DatatypeProperty> <camera:Camera rdf:ID="camera1"> <camera:name>Kodak</camera:name> </camera:Camera>

24 <owl:Class rdf:ID="Camera">
<rdfs:subClassOf rdf:resource="#Item"/> </owl:Class> <owl:Class rdf:ID="Lens"> <owl:ObjectProperty rdf:ID="compatibleWith"> <rdfs:domain rdf:resource="#Camera"/> <rdfs:range rdf:resource="#Lens"/> </owl:ObjectProperty> <camera:Lens rdf:ID=“lens1“ /> <camera:Camera rdf:ID="camera1"> <camera:compatibleWith rdf:resource="#lens1" /> </camera:Camera>

25 Manejando Instancias URI = OntClass c = model.getOntClass(URI +#Camera") OntProperty p = model.getOntProperty(URI +#name") Individual ind = model.getIndividual(URI +#camera1") if (ind.hasProperty(p)) Statement st = ind.getProperty(p); Object l = (Object)st.getObject();

26 Manejando Instancias Otras operaciones: model.listIndividuals()
Todas las instancias del Modelo individual.hasProperty(Property p,Object o) Retorna True si el objeto individual tiene la propiedad p con valor o ontClass.listInstances(); Todas las instancias de la clase

27 Validando OWL Validación Básica de OWL
Valida sintaxis no infiere ni razona. Para validaciones mas complejas: Jena 2  Inference Support Detecta la violación de las restricciones definidas en el schema por las instancias

28 Jena Inference Support
Inferir  Deducir información adicional El código que realiza la tarea de inferir se le llama razonador (Reasoner) Jena incluye un conjunto básico de razonadores OWL Reasoner DAML Reasoner RDF Rule Reasoner Generic Rule Reasoner Da un mecanismo para incluir nuevos razonadores

29 Validación en Jena Model schema = ModelLoader.loadModel("file:c:/Schema.owl"); Model data = ModelLoader.loadModel("file:c:/ejemplo.owl"); Reasoner reasoner = ReasonerRegistry.getOWLReasoner(); reasoner = reasoner.bindSchema(schema); InfModel modelInf = ModelFactory.createInfModel(reasoner, data); ValidityReport vrp1 = modelInf.validate(); if (vrp1.isValid()){ System.out.println(“OWL VALIDO"); }else { System.out.println(“OWL NO VALIDO"); for (Iterator i = vrp1.getReports(); i.hasNext();){ System.out.println(" - " + i.next()); }

30 <camera:Camera rdf:ID="camera1">
<camera:name>KODAK</camera:name> </camera:Camera> <owl:DatatypeProperty rdf:ID="name"> <rdfs:domain rdf:resource="#Camera"/> <rdfs:range rdf:resource=“xsd:integer"/> </owl:DatatypeProperty> Error (range check): Incorrectly typed literal due to range (prop, value) Culprit = Implicated node: Implicated node: 'KODAK‘

31 <owl:Class rdf:ID="Camera"> <rdfs:subClassOf>
<owl:Restriction> <owl:onProperty rdf:resource="#name" /> <owl:maxCardinality rdf:datatype=“xsd:nonNegativeInteger">1</owl:maxCardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <camera:Camera rdf:ID="camera1"> <camera:name>KODAK</camera:name> <camera:name>OLIMPUS</camera:name> </camera:Camera> Error (too many values): Too many values on max-N property (prop, class) Culprit = Implicated node: Implicated node:

32 Ejemplo: Ontología de Cámaras

33 <camera:Camera rdf:ID="camera1">
<camera:name>KODAK</camera:name> </camera:Camera> <camera:Lens rdf:ID=“lens1"> <camera:name>Lente_1</camera:name> </camera:Lens> <owl:DatatypeProperty rdf:ID="name"> <rdfs:domain rdf:resource="#Camera"/> <rdfs:range rdf:resource=“xsd:integer"/> </owl:DatatypeProperty>

34 Paradigma Orientado a Objetos rdfs:domain significaría “this is the class of objects to which this property can be applied.” rdfs:domain no describe que es legal. El statement <P rdfs:domain C> significa “all things to which P is applied can be inferred to have class C.”

35 Jena Inference Support
Inferir  Deducir información adicional El código que realiza la tarea de inferir se le llama razonador (Reasoner) Jena incluye un conjunto básico de razonadores OWL Reasoner DAML Reasoner RDF Rule Reasoner Generic Rule Reasoner Da un mecanismo para incluir nuevos razonadores

36 Jena Inference Support
Para hacer inferencias debemos crear un Modelo Inferido a partir de un razonador Ej: Reasoner reasoner = ReasonerRegistry.getOWLReasoner(); reasoner = reasoner.bindSchema(schema); InfModel modelInf = ModelFactory.createInfModel(reasoner, data); Todas las consultas que le hacemos al modelo inferido, infiere información

37 Jena Inference Support
GENERIC RULE REASONER OWL FB REASONER

38 Jena Inference Support
Generic Rule Reasoner: Inferencia basada en Reglas. Cada regla es una lista de Premisas y Conclusiones T1,T2 ………., TN  TO T = triple patterns como (?x rdf:type ?C) Si T1…….TN “matchea” en el conjunto de datos entonces T0 puede ser deducido

39 Jena Inference Support
SubClass (?A rdfs:subClassOf ?B) (?B rdfs:subClassOf ?C)  (?A rdfs:subClassOf ?C)

40 Jena Inference Support
Generic Rule Reasoner: Dos Motores de Inferencia Forward Chaining engine Se chequea cada una de las reglas para ver si los datos satisfacen las premisas de alguna de las reglas. Si una regla es satisfecha, es ejecutada derivando nuevos hechos que pueden ser utilizados por otras reglas para derivar hechos adicionales. Backward Chaining engine parte de los objetivos y trata de cumplir las condiciones necesarias para llegar a ellos. Cuando el Modelo Inferido es consultado, transforma la consulta en un Objetivo Ejecución similar a los motores PROLOG

41 is1 = (?A is ?B) (?B is ?C)  (?A is ?C) Forward Chaining engine
objetivo: A is C ? datos: A is B B is C reglas : is2 = (?A p ?B)  (?A is ?C) is1 = (?A is ?B) (?B is ?C)  (?A is ?C) Forward Chaining engine Aplica la regla is2 y no llega a cumplir el objetivo Aplica la regla is1 y llega a cumplir el objetivo Backward Chaining engine el objetivo se “matchea” con el objetivo de is2 , luego a partir de los hechos no se cumple las premisas el objetivo se “matchea” con el objetivo de is1 , luego a partir de los hechos se cumple las premisas

42 Jena Inference Support
Generic Rule Reasoner: Se puede usar los dos motores a la vez Ejemplo: (?p rdfs:subPropertyOf ?q),notEqual(?p,?q)  [ (?a ?q ?b)  (?a ?p ?b) ]

43 Jena Inference Support
Como invocar al Generic Rule Reasoner: //Creo el String de las reglas String ruleSrc = “[rule1: (?a eg:p ?b) (?b eg:p ?c)  (?a eg:p ?c)]”; //Parseo el String de las reglas List rules = Rule.parseRules(ruleSrc); //Construyo el Razonador Reasoner reasoner = new GenericRuleReasoner(rules);

44 Jena Inference Support
Archivos de reglas para los razonadores predefinidos DIR_INSTALACION\Jena-2.1\etc Ejemplo : owl-fb.rules

45 RDQL RDF Data Query Language. Es un lenguaje de consultas para RDF.
Enfoque totalmente declarativo. Considera un modelo RDF como un conjunto de tripletas: (Sujeto Propiedad Valor) Permite especificar patrones que son matcheados contra las tripletas del modelo para retornar un resultado.

46 Ejemplo

47 Ejemplo q1 contiene la consulta:
SELECT ?x WHERE (?x < "John Smith") Para ejecutar q1 sobre el modelo m1.rdf: java jena.rdfquery --data m1.rdf --query q1 La salida es: x ============================= <

48 Ejemplo Retornar todos los recursos que tienen la propiedad FN y su valor: SELECT ?x, ?fname WHERE (?x < ?fname) La salida es: x | fname ================================================ < | "John Smith" < | "Sarah Jones" < | "Matt Jones"

49 Ejemplo Retornar los nombres de los Jones: La salida es:
SELECT ?givenName WHERE (?y < "Jones"), (?y < ?givenName) La salida es: givenName ========= "Matthew" "Sarah"

50 Uso desde Java Se pueden realizar consultas en RDQL desde una aplicación Java. Se usan las siguientes clases: Query QueryExecution QueryEngine QueryResults ResultBinding

51 Ejemplo SELECT ?x, ?fname WHERE (?x < ?fname) Query query = new Query("SELECT...") ; query.setSource(model); QueryExecution qe = new QueryEngine(query) ; QueryResults results = qe.exec(); for (Iterator iter = results; iter.hasNext();) { ResultBinding res = (ResultBinding) iter.next(); Resource x = (Resource) res.get("x"); Literal fname = (Literal) res.get("fname"); System.out.println("x: " + x + " fname: " + fname); }

52 Modelos Persistentes Jena permite crear modelos persistentes:
Son persistidos de forma transparente en una base de datos relacional. Jena 2 soporta: MySQL Oracle PostgreSQL Para crear un modelo persistente se usa: ModelFactory.createModelRDBMaker(conn).createModel()

53 Ejemplo // Crear la conexión a la BD
DBConnection c = new DBConnection(DB_URL, DB_USER, DB_PASS, DB_TYPE); // Crear un ModelMaker para modelos persistentes ModelMaker maker = ModelFactory.createModelRDBMaker(c); // Crear un nuevo modelo Model model = maker.createModel("modelo_1"); // Comenzar una transacción model.begin(); // Leer el modelo de un archivo XML model.read(in, null); // Hacer el commit de la transacción model.commit();

54 Referencias Sitio Oficial de Jena 2 http://jena.sourceforge.net/
Jena 2 Ontology API An Introduction to RDF and the Jena RDF API

55 Referencias A Programmer's Introduction to RDQL
Jena2 Database Interface Jena 2 Inference support