Tutorial de JENA

Santiago Atella

Nicolás Genta

Diego González

INCO - FING - UDELAR

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.

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.

RDF• Recurso:

– 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.

Statements

• Cada statement tiene tres partes:– Sujeto, Predicado y Objeto.

• Un modelo RDF es un conjunto de statements.

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.

Ejemplo: vcards

Crear un modelo RDFString 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));

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), "");

Navegar un modelo

• A partir de la URI de un recurso:

// recuperar el recurso John Smith

String johnSmithURI = "http://somewhere/JohnSmith";

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)

.getObject();

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.

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);

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>

<owl:Class rdf:ID="DigitalCamera"> <rdf:type owl:Restriction /></owl:Class>

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);

Ejemplo: Ontología de Cámaras

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);

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());

}

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);

Propiedades

• DatatypeProperties• ObjectProperties

– FunctionalProperty– TransitiveProperty– SymmetricProperty– InverseFunctionalProperty

• Proporciona métodos isXXX para testear el tipo de una propiedad:– Ejemplo: isTransitiveProperty()

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>

// 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}));

Schema vs Instancia• Schema

– Se puede definir las:• Clases• Propiedades (DataTypeProperty, ObjectProperty)• Restricciones

– Tipos de Datos– Cardinalidad

• Instancia– Definimos la instancias (individuos) de los

elementos del Schema.

<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>

<owl:Class rdf:ID="Camera"> <rdfs:subClassOf rdf:resource="#Item"/> </owl:Class><owl:Class rdf:ID="Lens"> <rdfs:subClassOf rdf:resource="#Item"/></owl:Class> <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>

Manejando Instancias

URI = http://test/camera/#Camera

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();

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

Validando OWL

• Validación Básica de OWL– http://owl.bbn.com/validator/– 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

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

Validación en JenaModel 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()); }

<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 = http://www.xfront.com/owl/ontologies/camera/#camera1Implicated node: http://www.xfront.com/owl/ontologies/camera/#nameImplicated node: 'KODAK‘

<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 = http://www.xfront.com/owl/ontologies/camera/#camera1Implicated node: http://www.xfront.com/owl/ontologies/camera/#nameImplicated node: http://www.xfront.com/owl/ontologies/camera/#Camera

Ejemplo: Ontología de Cámaras

<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>

• 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.”

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

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

Jena Inference Support

OWL FB REASONEROWL FB

REASONER

GENERIC RULE REASONER

GENERIC RULE REASONER

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

Jena Inference Support• SubClass

(?A rdfs:subClassOf ?B)

(?B rdfs:subClassOf ?C)

(?A rdfs:subClassOf ?C)

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

objetivo: A is C ?datos: A is B

B is Creglas :is2 = (?A p ?B) (?A is ?C)is1 = (?A is ?B) (?B is ?C) (?A is ?C)

• Forward Chaining engineAplica la regla is2 y no llega a cumplir el objetivoAplica la regla is1 y llega a cumplir el objetivo

• Backward Chaining engineel objetivo se “matchea” con el objetivo de is2 , luego a partir de los hechos no se cumple las premisasel objetivo se “matchea” con el objetivo de is1 , luego a partir de los hechos se cumple las premisas

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) ]

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);

Jena Inference Support• Archivos de reglas para los razonadores predefinidos

DIR_INSTALACION\Jena-2.1\etc

• Ejemplo : owl-fb.rules

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.

Ejemplo

Ejemplo

• q1 contiene la consulta:

SELECT ?x

WHERE (?x <http://www.w3.org/2001/vcard-rdf/3.0#FN> "John Smith")

• Para ejecutar q1 sobre el modelo m1.rdf:

java jena.rdfquery --data m1.rdf --query q1

• La salida es:

x

=============================

<http://somewhere/JohnSmith/>

Ejemplo

• Retornar todos los recursos que tienen la propiedad FN y su valor:

SELECT ?x, ?fname

WHERE (?x <http://www.w3.org/2001/vcard-rdf/3.0#FN> ?fname)

• La salida es:

x | fname

================================================

<http://somewhere/JohnSmith/> | "John Smith"

<http://somewhere/SarahJones/> | "Sarah Jones"

<http://somewhere/MattJones/> | "Matt Jones"

Ejemplo

• Retornar los nombres de los Jones:

SELECT ?givenName

WHERE (?y <http://www.w3.org/2001/vcard-rdf/3.0#Family> "Jones"),

(?y <http://www.w3.org/2001/vcard-rdf/3.0#Given> ?givenName)

• La salida es:

givenName

=========

"Matthew"

"Sarah"

Uso desde Java

• Se pueden realizar consultas en RDQL desde una aplicación Java.

• Se usan las siguientes clases:– Query– QueryExecution– QueryEngine– QueryResults– ResultBinding

EjemploSELECT ?x, ?fname

WHERE (?x <http://www.w3.org/2001/vcard-rdf/3.0#FN> ?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);

}

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()

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();

Referencias

Sitio Oficial de Jena 2

http://jena.sourceforge.net/

Jena 2 Ontology API

http://jena.sourceforge.net/ontology/

An Introduction to RDF and the Jena RDF API

http://jena.sourceforge.net/tutorial/RDF_API/

Referencias

A Programmer's Introduction to RDQL

http://jena.sourceforge.net/tutorial/RDQL/

Jena2 Database Interface

http://jena.sourceforge.net/DB/

Jena 2 Inference support

http://jena.sourceforge.net/inference/