LA WEB SEMÁNTICA. OWL

LA WEB SEMÁNTICA. OWL
PROPÓSITO
Introducir el lenguaje OWL y programar ontologías con las APIs Jena y OWLAPI
INTRODUCCION
OWL (Ontology Web Language) es un lenguaje diseñado para formalizar ontologías. Su
expresividad es mayor que la propuesta por RDF/RDF Schema. Entre los recursos expresivos de
OWL destacan: unión, intersección, complemento y equivalencia de conceptos, roles
funcionales, roles inversos, cuantificación existencial y universal en roles y restricciones
numéricas. Se adopta XML como sintaxis concreta de OWL.
En esta sección mostramos los recursos expresivos principales de OWL.
Declaración de clase (concepto):
<rdf:Description
rdf:about="http://www.lsi.us.es/ontologia1#Organismo_Publico">
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
</rdf:Description>
Declaración de propiedad (rol) con dominio y rango:
<rdf:Description
rdf:about="http://www.lsi.us.es/ontologia1#da_clases_en">
<rdfs:range
rdf:resource="http://www.lsi.us.es/ontologia1#Asignatura"/>
<rdfs:domain
rdf:resource="http://www.lsi.us.es/ontologia1#Profesor"/>
<rdf:type
rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>
</rdf:Description>
Declaración de subclase (subconcepto):
<rdf:Description
rdf:about="http://www.lsi.us.es/ontologia1#Colaborador">
<rdfs:subClassOf
rdf:resource="http://www.lsi.us.es/ontologia1#Profesor"/>
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
</rdf:Description>
Equivalencia entre clases (conceptos):
<rdf:Description
rdf:about="http://www.lsi.us.es/ontologia1#Docente_Funcionario">
<owl:equivalentClass
rdf:resource="http://www.lsi.us.es/ontologia1#Titular"/>
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
</rdf:Description>
LA WEB SEMÁNTICA. OWL
Complemento de clase (concepto):
<rdf:Description
rdf:about="http://www.lsi.us.es/ontologia1#Docente_No_Funcionario">
<owl:complementOf
rdf:resource="http://www.lsi.us.es/ontologia1#Docente_Funcionario"/>
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
</rdf:Description>
Declaración de propiedad (rol) funcional :
<rdf:Description
rdf:about="http://www.lsi.us.es/ontologia1#tiene_asignado_el_despacho"
>
<rdf:type
rdf:resource="http://www.w3.org/2002/07/owl#FunctionalProperty"/>
<rdf:type
rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>
</rdf:Description>
Declaración de restricciones con cuantificación universal sobre un rol:
<rdf:Description rdf:nodeID="A3">
<owl:allValuesFrom
rdf:resource="http://www.lsi.us.es/ontologia1#Departamento"/>
<owl:onProperty
rdf:resource="http://www.lsi.us.es/ontologia1#trabaja_en"/>
<rdf:type
rdf:resource="http://www.w3.org/2002/07/owl#Restriction"/>
</rdf:Description>
Declaración de restricciones numéricas sobre un rol:
<rdf:Description rdf:nodeID="A4">
<owl:minCardinality
rdf:datatype="http://www.w3.org/2001/XMLSchema#int">1</owl:minCardinal
ity>
<owl:onProperty
rdf:resource="http://www.lsi.us.es/ontologia1#da_clases_en"/>
<rdf:type
rdf:resource="http://www.w3.org/2002/07/owl#Restriction"/>
</rdf:Description>
Declaración de clases disjuntas:
<rdf:Description rdf:about="http://www.lsi.us.es/ontologia1#Ayudante">
<owl:disjointWith
rdf:resource="http://www.lsi.us.es/ontologia1#Colaborador"/>
<owl:disjointWith
rdf:resource="http://www.lsi.us.es/ontologia1#Titular"/>
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
</rdf:Description>
LA WEB SEMÁNTICA. OWL
PROGRAMANDO DOCUMENTOS OWL CON JENA
En el contexto tecnológico, destacan dos APIs para programar ontologías OWL: Jena y OWLAPI.
Esta sección introducimos el API Jena.
Declaración de una ontología OWL:
OntModel m =
ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM_RULE_INF);
Establecimiento de la dirección base (dirección lógica):
String prefijo = "http://www.lsi.us.es/ontologia1#";
m.setNsPrefix("", prefijo);
Declaración de clase (concepto):
m.createClass(prefijo + "Curso");
Declaración de propiedad (rol) con dominio y rango:
m.createObjectProperty(prefijo + "esta_adscrita_a");
m.getObjectProperty(prefijo +
"esta_adscrita_a").addDomain(m.getOntClass(prefijo +
"Asignatura"));
m.getObjectProperty(prefijo +
"esta_adscrita_a").addRange(m.getOntClass(prefijo +
"Departamento"));
Declaración de subclase (subconcepto):
m.getOntClass(prefijo +
"Profesor").addSubClass(m.getOntClass(prefijo +
"Titular"));
Unión de clases (conceptos):
RDFList l = m.createList();
RDFNode n = m.getResource(prefijo + "Ayudante");
l = l.cons(n);
n = m.getResource(prefijo + "Titular");
l = l.cons(n);
n = m.getResource(prefijo + "Colaborador");
l = l.cons(n);
m.createUnionClass(prefijo + "Profesor", l);
Intersección de clases (conceptos):
RDFList l2 = m.createList();
n = m.getResource(prefijo + "Funcionario");
l2 = l2.cons(n);
n = m.getResource(prefijo + "Docente");
LA WEB SEMÁNTICA. OWL
l2 = l2.cons(n);
m.createIntersectionClass(prefijo + "Docente_Funcionario", l2);
Complemento de clase (concepto):
m.createClass(prefijo+"Docente_No_Funcionario").convertToComplementCla
ss(m.getOntClass(prefijo+"Docente_Funcionario"));
Declaración de propiedad (rol) funcional :
m.getOntProperty(prefijo +
"esta_adscrita_a").convertToFunctionalProperty();
Declaración de restricciones con cuantificación universal sobre un rol:
m.createRestriction(m.getOntProperty(prefijo+"trabaja_en")).convertToA
llValuesFromRestriction(m.getOntResource(prefijo+"Departamento")).addS
ubClass(m.getOntClass(prefijo+"Profesor"));
Declaración de restricciones numéricas sobre un rol:
m.createRestriction(m.getObjectProperty(prefijo +
"da_clases_en")).convertToMinCardinalityRestriction(1).addSubClass(m.g
etOntClass(prefijo+"Profesor"));
Declaración de clases disjuntas:
m.getOntClass(prefijo +
"Ayudante").addDisjointWith(m.getOntClass(prefijo +
"Titular"));
PROGRAMANDO DOCUMENTOS OWL CON OWLAPI
En el contexto tecnológico destacan dos APIs para programar ontologías: Jena y OWLAPI.
Esta sección introducimos el API OWLAPI.
Lectura de ontología remota y crear una copia local:
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
URI uri = URI.create(
"http://www.co-ode.org/ontologies/pizza/2005/05/16/pizza.owl");
OWLOntology ontology = manager.loadOntology(uri);
URI uri2 = URI.create(
"file:/C://Users//Fran//Docencia//Master//Temario//Tema8//pizza.owl");
manager.saveOntology(ontology, new OWLXMLOntologyFormat(), uri2);
LA WEB SEMÁNTICA. OWL
Crear una ontología:
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
URI base = URI.create("http://www.lsi.us.es/ontologia5");
URI uri = URI.create(
"file:/C://Users//Fran//Docencia//Master//Temario//Tema8//ontologia5.o
wl");
OWLOntology ontologia = manager.createOntology(base);
OWLDataFactory factory = manager.getOWLDataFactory();
Subclase:
OWLClass clase1 = factory.getOWLClass(URI.create(base+"#Profesor"));
OWLClass clase2 = factory.getOWLClass(URI.create(base+"#Titular"));
OWLAxiom axioma = factory.getOWLSubClassAxiom(clase2, clase1);
AddAxiom change = new AddAxiom(ontologia,axioma);
manager.applyChange(change);
Clases disjuntas:
Set<OWLDescription> clases = new HashSet<OWLDescription>();
clase1 = factory.getOWLClass(URI.create(base+"#Titular"));
clases.add(clase1);
clase1 = factory.getOWLClass(URI.create(base+"#Ayudante"));
clases.add(clase1);
clase1 = factory.getOWLClass(URI.create(base+"#Colaborador"));
clases.add(clase1);
change =
new AddAxiom (ontologia,factory.getOWLDisjointClassesAxiom(clases));
manager.applyChange(change);
Intersección de clases y equivalencia:
clases = new HashSet<OWLDescription>();
clase1 = factory.getOWLClass(URI.create(base+"#Docente"));
clases.add(clase1);
clase1 = factory.getOWLClass(URI.create(base+"#Funcionario"));
clases.add(clase1);
OWLObjectIntersectionOf interseccion =
factory.getOWLObjectIntersectionOf(clases);
clase2 = factory.getOWLClass(URI.create(base+"#Docente_Funcionario"));
change = new AddAxiom(ontologia,
factory.getOWLEquivalentClassesAxiom(clase2, interseccion));
manager.applyChange(change);
Rol. Dominios y rangos:
OWLObjectPropertyExpression propiedad =
factory.getOWLObjectProperty(URI.create(base+"#esta_adscrita_a"));
clase1 = factory.getOWLClass(URI.create(base+"#Asignatura"));
change = new AddAxiom(ontologia,
factory.getOWLObjectPropertyDomainAxiom(propiedad, clase1));
manager.applyChange(change);
clase2 = factory.getOWLClass(URI.create(base+"#Departamento"));
LA WEB SEMÁNTICA. OWL
change = new AddAxiom(ontologia,
factory.getOWLObjectPropertyRangeAxiom(propiedad, clase2));
manager.applyChange(change);
Roles funcionales:
propiedad =
factory.getOWLObjectProperty(URI.create(base+"#esta_adscrita_a"));
change = new AddAxiom(ontologia,
factory.getOWLFunctionalObjectPropertyAxiom(propiedad));
manager.applyChange(change);
propiedad2 = factory.getOWLDataProperty(
URI.create(base+"#tiene_asignado_el_despacho"));
change = new AddAxiom(ontologia,
factory.getOWLFunctionalDataPropertyAxiom(propiedad2));
manager.applyChange(change);
Cuantificación universal:
propiedad =
factory.getOWLObjectProperty(URI.create(base+"#trabaja_en"));
clase1 = factory.getOWLClass(URI.create(base+"#Departamento"));
clase2 = factory.getOWLClass(URI.create(base+"#Profesor"));
OWLObjectAllRestriction restriccion1 =
factory.getOWLObjectAllRestriction(propiedad, clase1);
axioma = factory.getOWLSubClassAxiom(clase2, restriccion1);
change = new AddAxiom(ontologia,axioma);
manager.applyChange(change);
Restricción numérica:
propiedad =
factory.getOWLObjectProperty(URI.create(base+"#da_clases_en"));
clase1 = factory.getOWLClass(URI.create(base+"#Asignatura"));
clase2 = factory.getOWLClass(URI.create(base+"#Profesor"));
OWLObjectMinCardinalityRestriction restriccion2 =
factory.getOWLObjectMinCardinalityRestriction(propiedad, 1, clase1);
axioma = factory.getOWLSubClassAxiom(clase2, restriccion2);
change = new AddAxiom(ontologia,axioma);
manager.applyChange(change);
Aserto (clase):
OWLIndividual ind1 =
factory2.getOWLIndividual(URI.create(base2+"#PL1"));
OWLClass clase =
factory1.getOWLClass(URI.create(base1+"#Asignatura"));
AddAxiom change = new
AddAxiom(ontologia2,factory2.getOWLClassAssertionAxiom(ind1, clase));
manager2.applyChange(change);
LA WEB SEMÁNTICA. OWL
Aserto (rol):
ind1 = factory2.getOWLIndividual(URI.create(base2+"#PL1"));
OWLIndividual ind2 = factory2.getOWLIndividual(create(base2+"#LSI"));
OWLObjectProperty propiedad =
factory1.getOWLObjectProperty(URI.create(base1+"#esta_adscrita_a"));
change = new AddAxiom(ontologia2,
factory2.getOWLObjectPropertyAssertionAxiom(ind1,
propiedad, ind2));
manager2.applyChange(change);
Mezclar ontologías:
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
manager.loadOntologyFromPhysicalURI(URI.create("file:/C://Users//Fran/
/Docencia//Master//Temario//Tema8//ontologia5.owl"));
manager.loadOntologyFromPhysicalURI(URI.create("file:/C://Users//Fran/
/Docencia//Master//Temario//Tema8//modelo5.owl"));
OWLOntologyMerger mezclador = new OWLOntologyMerger(manager);
URI base = URI.create("http://www.lsi.us.es/ontologia6");
OWLOntology ontologia = mezclador.createMergedOntology(manager, base);
TRABAJO PROPUESTO




Consulte la documentación suministrada por W3C en relación a OWL.
Consulte la documentación suministrada por Jena en relación a las ontologías OWL.
Programe con Jena una ontología OWL para la terminología propuesta en el Problema
1 del Tema 2.
Consulte la documentación suministrada por OWLAPI y programe una ontología OWL
para la terminología propuesta en el Problema 1 del Tema 2.