En cuanto a las tecnologías semánticas y en relación con el ámbito de la gobernanza electrónica -especialmente respecto de la interoperabilidad-, me ha parecido muy oportuno dar una pincelada de una cuestión que está suscitando un debate interesante a nivel científico y tecnológico.

Existe un debate sobre la oportunidad de la elección de un esquema basado en ontologías detalladas (“top-down”) (una ontología, es una especificación explícita formal de un cuerpo de conceptos compartidos, compuesta además por relaciones entre conceptos -o también entre propiedades de conceptos-, instancias de los conceptos y axiomas) o un enfoque de lo que se podría denominar aproximación basada en vocabulario (“bottom-up”) en determinados ámbitos de la gobernanza electrónica.

Así lo han puesto de manifiesto autores como Berners-Lee en “Putting Government Data Online” (W3C, Junio de 2009) o Abecker y otros en “Transforming e-Government and e-Participation through IT” (IEEE Intelligent Systems, Septiembre/Octubre 2009). Ello es debido a que las ontologías presentan también importantes dificultades que aparecen tanto en el momento de desarrollarse como en las fases de adopción y uso, siendo posible que la disponibilidad de la información a través de un enfoque bottom-up, pueda permitir más fácilmente que terceros accedan y traten la información del sector público más pronto -lo más pronto posible-, de un modo mucho menos complejo, y ser más rápidamente alcanzable.

Saludos,

Carlos E. Jiménez

Estou aqui enlouquecendo trabalhando na minha dissertação (aqui em PT, tese) de mestrado e resolvi compartilhar um pouco dessa experiência. É um trabalho violento e árduo, mas espero que valha a pena.

Espero que depois que pronta eu consiga publicar (em conferências INTERNACIONAIS) e participar de concursos de dissertações de mestrado da SBC. Poderia ter feito isso já com o TCC da graduação aqui mas do ponto de vista de Recuperação de Informação o que eu fiz como estudo de caso foi muito pequeno (só prova de conceito, praticamente um toy example) e eu não dei prosseguimento ao sistema. Isso tudo feito às pressas pra conseguir o grau antes de ir pra Recife pro mestrado, apesar do 10 unânime de uma banca cabulosa lá da UFAL (modéstia à Marte).

Além disso, tive que aprender Recuperação de Informação (RI) e Aprendizagem de Máquina (AM) sozinho! Só por isso já mereço um prêmiozinho…

Nuvem de tags - ORGANIZE A WEB, MOTHAFUCKA

Bom, o assunto da dissertação: Folksonomias e Sugestão de tags. Construí (?) um sistema que extraiu dados do Delicious e depois usei técnicas de RI, AM e outras coisas. Usei como base da sugestão de tags pra páginas Web o conteúdo textual (implementado, preciso e lindo!), páginas vizinhas (inbound pages) (80% implementado) e informação do WordNet e ontologias (Aqui há dragões no código! Trabalhando nisso!). No final faço uma comparação entre as tags que sugeri e as tags do Delicious pra dar uma medida quantitativa do quanto o sistema é bom e uma análise do comportamento do usuário (p. ex. que tipo de tags o sistema NUNCA vai sugerir: “semweb” e “webdev” fica difícil).

Já passei do nível de loucura com esse sistema, o que pode ser melhor visto na quantidade de linhas de código da bagaça (inclui somente .java, código e testes). Mas vamo nessa, não desisto NUNCA!

Ia colocar o abstract aqui, mas como é um trabalho não-publicado (malditos revisores animais, alguns nem entenderam o sistema) vou deixar pra depois pra falar dos louros que consegui com o trabalho.

Boa noite, boa sorte (pra mim)!

Hace algún tiempo, cuando estudiaba Ingeniería en Sistemas en la USAC llevé el curso de Inteligencia Artificial, IA tiene un contenido muy extenso y me acuerdo que en esa oportunidad solo alcanzamos a ver tres puntos:

- Introducción a Sistemas Expertos, donde utilizamos una herramienta de software llamada EHSIS basada en CLIPS.

- Algoritmos Genéticos, una implementación de rutas cortas desarrollado con JAVA (pronto les publico un link).

- Búsquedas Inteligentes a traves de Ontologías, utilizamos conceptos de Web Semántica y desarrollé un proyecto turístico “ontoguate“ basado en una ontología para búsquedas inteligentes, desarrollado en PHP y un poco AJAX.

Sin embargo, ahora me doy cuenta que faltaban ciertas cosas importantes, empezando con la Resolución de Problemas basados en estados y los “famosos algoritmos de búsquedas”, tales como el de anchura , profundidad, el mejor primero, el de las colinas, etc… que en la mayoría de libros los separa por búsquedas no informadas e informadas, los cuales, se refieren a que si hay cierta heurística para solucionar el problema o si a ciegas se hará. Todo esto debido al curso de Inteligencia Artificial de la maestría que estoy sacando en el Tecnológico de Costa Rica con Francisco Torres Ph.D.

Actualmente estoy desarrollando un pequeño proyecto programado para resolver un problema que tiene que ver con costos y recursos, el cual lo estoy desarrollando en LISP, especificamente con GCL, y es por ello el escribir esta entrada del blog. Despues de varios años programando me toca programar en un lenguaje funcional y para ser sincero “no es nada fácil”, mas que todo por el cambio de paradigma y ver las cosas desde otro punto de vista, sin embargo, como buen sancarlista lo hago a como dé lugar, jeje. Pronto les publico el código fuente del proyecto para los interesados en LISP.

Actualización: Septiembre 8, 2009

Lo prometido es deuda, este es el link de la Implementación de Algoritmos de Búsqueda en Common Lisp.

El encuentro entra la computación, la matemática y la filosofía ha convertido el campo científico de las Tecnologías de la Web en un área de vanguardia de primera magnitud científica. La Universidad de Oxford lo sabe y decidió convertir su Oxford University Computing Laboratory en una referencia mundial ya que en el campo de la Web Semántica se esta dando el tan esperado encuentro entre las Ciencias de la Computación y las Humanidades.

El invitado del programa Tecnópolis UPTV, Bernardo Cuenca Grau, es un investigador del Oxford University Computing Laboratory especializado en Tecnologías basadas en Ontologías para la Web Semántica y en Sistemas de Representación del Conocimiento. Trabaja en el Information Systems Group de dicho laboratorio que lideran los científicos  de la Universidad de Oxford Ian Horrocks y Georg Gottlob. Bernardo, acaba de ser premiado por la Royal Society británica con una “Royal Society University Research Fellowship” que le financia sus próximos cinco años (prorrogables a ocho) de investigación en el Laboratorio de Computación de la Universidad de Oxford. En este programa, Bernardo Cuenca Grau describe, entre otras cosas, su trayectoria científica que le ha llevado a la primera universidad europea, el funcionamiento del mundo científico de dicha universidad y explica también en qué consisten las Tecnologías Basadas en Ontologías para la Web Semántica y sus aplicaciones en el mundo real.

Completa el programa otro invitado de excepción: Jimmy Wales, fundador de Wikipedia, la enciclopedia libre de la red que posee una de las ontologías de referencia globlal en la Web social y colaborativa en forma de wiki. Jimmy Wales habla sobre Wikipedia en el programa Tecnópolis UPTV de esta semana. Colabora en la traducción de esta entrevista Antonio Córdoba, profesor asistente de la Universidad de Harvard.

Este programa se emitirá el miércoles 1 de Julio, de las 13.30 a 14.30 h. y de 21.30 a 22.30 h. (horas de España). Y se re-emite el domingo 4 de Julio con el mismo horario.

La televisión de la Universidad Politécnica de Valencia emite en abierto en el área metropolitana de Valencia, por el canal 45 UHF; en TV por cable en España, por el canal 989 de Ono y, por el satélite Hispasat para Iberoamérica.

Puedes ver el programa ahora a través de este blog de TECNÓPOLIS UP TV, pulsando sobre la imagen:

En este artículo vamos a ver cómo podemos crear una ontología fácilmente utilizando la API de ProtegeOWL 3.4 y usando como lenguaje de programción Java con el IDE Eclipse.

Lo primero que debemos tener en cuenta es que debemos tener instalada la API de Protege y haberla configurado en nuestro proyecto de Eclipse. Aquí podéis ver cómo instalar y configurar la API.

La ontología que crearemos es muy sencilla. El objetivo es aprender: cómo crear Clases, cómo definir Subclases, cómo añadir propiedades de datos a esas clases y por último como crear instancias y dar valores a las propiedades.

NOTA: Recordad, que los valores que demos a cada una de las propiedades, se establecen a nivel de Instancias, es decir, son las instancias las que tienen valores concretos para las propiedades. En las clases sólo definiremos el rango y el dominio de la propiedad.

La ontología representará una taxonomía de Animales (muuuuuuy simple). Un animal podrá ser invertebrado o vertebrado y un animal tendrá una propiedad que es el “Peso”, cuyo rango (tipo) será float.

Por tanto la propiedad “Peso” tendrá como dominio Animal y como rango Float.

Por último crearemos dos instancias, una para vertebrados y otra para invertebrados. Leopardo y Pulpo por ejemplo.

Pues sin más vamos a ver el código:

public class JenaMain {
  public static void main(String[] args) {
    try {

      JenaOWLModel jModel;
      Collection errors = new ArrayList();
      jModel = ProtegeOWL.createJenaOWLModel();

	//Establecemos la URI principal de nuestra ontologia
	jModel.getDefaultOWLOntology()
              .rename("http://www.owl-ontologies.com/OntoAnimales.owl");
	//Establecemos el namespace por defecto
	jModel.getNamespaceManager()
              .setDefaultNamespace("http://www.owl-ontologies.com/OntoAnimales.owl#");

	//Obtenemos el namespace por defecto que acabamos de configurar
	String NS = jModel.getNamespaceManager().getDefaultNamespace();

	//Creamos la clase animal
	OWLNamedClass clsAnimal = jModel.createOWLNamedClass("Animales");
	//Vamos a crear las subclases Vertebrados e Invertebrados
	OWLNamedClass clsVert;
        clsVert = jModel.createOWLNamedSubclass("Vertebrados", clsAnimal);
        OWLNamedClass clsInVert;
        clsInVert = jModel.createOWLNamedSubclass("Invertebrados", clsAnimal);

	//Decimos que un vertebrado no puede ser invertebrado y viceversa
	//clsAnimal.setSubclassesDisjoint(true);

	//Vamos a crear algunas propiedades, como el peso,... o las que queramos
	OWLDatatypeProperty propPeso = jModel.createOWLDatatypeProperty("peso");
	propPeso.setFunctional(true);
	//Definimos la propiedad como Functional para que sólo pueda contener un
        //valor. En OWL cada propiedad puede contener una lista de valores, no un
        //único valor. Pero en este caso no nos interesa eso.

	//Asignamos la propiedad a la clase Animal
	propPeso.setDomain(clsAnimal);
	//Definimos el tipo (rango) de la propiedad como float
	propPeso.setRange(((OWLModel)jModel).getXSDfloat());

	//Vamos a crear un par de instancias
	OWLIndividual leopard = clsVert.createOWLIndividual("Leopardo");
	//Le asignamos un peso al leopardo
	leopard.setPropertyValue(propPeso, new Float(250.49f));

	//Creamos un pulpo
	OWLIndividual pulpo = clsInVert.createOWLIndividual("Pulpo");
	//Le asignamos un peso
	pulpo.setPropertyValue(propPeso, new Float(14.20f));

	//La Guardamos en un fichero owl
	jModel.save(new URI("file:///Users/Rekeb/Desktop/Animales.owl"),
                    FileUtils.langXMLAbbrev,errors);
	System.out.println("ERRORES: "+errors);

	} catch (OntologyLoadException oe){
		oe.printStackTrace();
	} catch (URISyntaxException e) {
		e.printStackTrace();
	}
   }
}

De esta forma, cuando termine de ejecutarse, tendremos en nuestro escritorio un fichero Animales.owl que contendrá nuestra ontología en lenguaje OWL y que además podremos abrir sin ningún problema con Protégé y podremos navegar por las clases que acabamos de crear, sus subclases y las instancias. El resultado debe ser parecido al siguiente:

Cuando trabajamos con ontologías, una de las formas más comunes de reutilizar datos entre ellas, es realizar imports. De esta manera añadiremos a nuestra ontología nuevos espacios de nombres, que nos van a permitir utilizar nuevos datos y ubicar y reconocer los datos existentes. Si ya habéis trabajado con reglas SWRL, os habréis dado cuenta de que, para poder crear reglas y manipularlas, es necesario llevar a cabo una serie de imports en nuestra ontología principal, que nos permita conocer los tipos de datos que se manejan en las reglas SWRL.

Si trabajais con Protégé, esta importación se lleva a cabo de forma automática simplemente pulsando un botón. Y el resultado es la adición de nuevas clases, propiedades e instancias a nuestra ontología.

En esta entrada veremos cómo añadir Imports y cómo eliminarlos de nuestra ontología usando la API Protégé-OWL.

La incorporación de nuevos imports a nuestra ontología es un proceso muy trivial. Muy simple. La incorporación de nuevos imports puede llevarse a cabo “al vuelo” sin necesidad de recargar la ontología. Vamos a ver cómo importamos una de las ontologías definidas por SWRL, por ejemplo.

Por supuesto, antes de nada, debemos asegurarnos de tener correctamente instalada la API de Protege-OWL en nuestro IDE. En mi caso estoy usando Eclipse 3.4.1 y la API de Protege descargada de los repositorios de Subversion.

Nota: Aquí podéis ver una guía de como instalar la API de Protege. Los ejemplos están puesto para Windows, pero funciona para cualquier plataforma. De hecho, yo en Windows no lo he probado jamás

Nota: En esta entrada cuento cómo instalar y configurar la API. Aquí describo el método que yo uso, que no quiere decir q sea el único ni el mejor

Una vez, tenemos todo configurado, veamos el código para realizar los imports:

//Creamos el modelo aux con la ontologia base
 JenaOWLModel jModel = ProtegeOWL.createJenaOWLModelFromURI(uri); //Puede lanzar una Exception
//uri será la ruta hacia nuestro fichero OWL que contendrá la ontología
//Si lo preferimos, podemos crear un modelo vacío con la siguiente instruccion:
//JenaOWLModel jModel = ProtegeOWL.createJenaOWLModel();

//Añadimos el espacio de nombres de la ontología que vamos a importar y le asignamos un prefijo
 jModel.getNamespaceManager().setPrefix(new URI("http://www.w3.org/2003/11/swrl#"), "swrl");

//Creamos un ImportHelper para llevar a cabo la importación
  ImportHelper importHelper = new ImportHelper((JenaOWLModel)jModel);

//Añadimos la ontología al conjunto de ontologías q van a ser importadas
//Este método NO realiza la importación de ontologías a nuestro jModel
  importHelper.addImport(new URI("file:///ruta/a/nuestra/ontologia/swrl.owl"));
//Añadiremos tantos .addImport como ontologías queramos importar
//(Por su puesto con sus correspondientes, espacio de nombres y prefijos)

//Ahora sí añadimos los imports q hemos estado configurando
  importHelper.importOntologies(false);
//El parámetro false indica que no recargue el GUI.
//Recordemos que la API de Protege, trae métodos para crear todo un interfaz de usuario completo

A partir de ahora ya tenemos importada la ontología y la tendremos incorporada a nuestro modelo. Por tanto podremos trabajar con ella sin ningún problema.

Recordemos que el método importOntologies, puede lanzar una excepción, asi es que debemos controlarla.

Veamos ahora la forma de eliminar un import. Esta acción puede no resultar tan trivial en primera instancia. Tenemos dos opciones para eliminar los imports:

1- Recargar todo el modelo OWL nuevamente

Una solución que he encontrado, consiste en realizar los siguientes pasos: (Ésta es la manera en la que la versión 3.3.1 de Protege elimina los imports)

1. Eliminar el import del modelo. En este punto y mientras el modelo siga en memoria, el import y sus referencias todavía no habrán sido eliminadas. Estos cambios no son reflejados hasta que guardemos el modelo en un fichero en el disco.
2. Eliminar los prefijos que hayamos creado.
3. Guardar el modelo en un fichero OWL. Lo que provoca que el fichero OWL se actualice con la ontología SIN los imports que hemos eliminado antes
4. Volver a cargar el modelo con el fichero que acabamos de guardar. Ahora sí, el modelo que tenemos en memoria no contiene los imports.

El código para llevar a cabo esta acción es el siguiente:

Primero necesitamos conocer la URL del import que vamos a eliminar, si no la conocemos, podemos obtenerla con: jModel.getAllImports()

jModel.getDefaultOWLOntology().removeImports("http://www.w3.org/2003/11/swrl.owl");
jModel.getNamespaceManager().removePrefix("swrl");

Collection errors = new ArrayList();
jModel.save(new URI("file:///ruta/al/fichero/owl/sinImports.owl"),
                                         FileUtils.langXMLAbbrev,errors);

//El siguiente paso es muy importante, ya que el mantener modelos de ontologias en memoria,
//requiere mucho espacio en la pila y como sabéis este espacio es bastante limitado.
//De esta forma le decimos a la JVM que puede eliminar el espacio ocupado por nuestro
//anterior modelo y evitar asi excepciones del tipo OutOfMemoryException :S
jModel.close();
jModel = null;

jModel = ProtegeOWL.createJenaOWLModelFromURI(
                      new URI("file:///ruta/a/fichero/owl/sinImports.owl").toString());

De esta forma habremos eliminado el import o los imports de nuestro modelo. Realmente funciona muy bien este método aunque su mayor inconveniente sin duda es el tiempo que se pierde en volver a cargar el modelo. Si hablamos de ontologías muy grande este tiempo puede ser en ocasiones exagerado.

2- Vaciar la caché sin recargar todo el modelo OWL:

Este segundo método funciona muy bien con la API 3.4 de ProtegeOWL. Con este metodo no es necesario que recarguemos nuevamente el modelo en memoria.

//Vaciamos la cache de nuestra ontología
((OWLModel)jModel).resetOntologyCache();
//Eliminamos los imports que nos interesen
jModel.getDefaultOWLOntology().removeImports("http://www.w3.org/2003/11/swrl.owl");
jModel.getNamespaceManager().removePrefix("swrl");
//Si ahora listamos los imports, veremos que el import que acabamos de eliminar
//no esta en nuestra ontologia.
System.out.println("Imports: "+jModel.getAllImports());

NOTA:Cuando hayamos realizado alguna operación sobre la ontología y después veamos que los datos que estamos obteniendo no corresponden a lo que deberíamos obtener, podemos vaciar la caché que utiliza Protegé para las ontologías sin necesidad de recargar todo el modelo.

Para más información consultad la API de Protege-OWL.

O visitad la página de Protégé, para estar atentos a novedades.

En esta lista de correo se propone otro tipo de solución.

Un poco de teoría sobre los imports en Protege | Protege-OWL Managing Imports

Comentarios, mejoras, sugerencias….

Las ontologías son esquemas de clasificación conceptual, que permiten tanto la ordenación de la información como la puesta en común entre sistemas. Gracias al uso de las ontologías la búsqueda de información es más rápida.

David Casacuberta, miembro de NetDrome, impartió un seminario sobre el papel de las ontologías en el ámbito de la Web Semántica, en el aula de Nuevas Tecnologías CAMON.

Netdrome.

Ya hay voces aventureras que están barruntando la posibilidad de la Web Ubicua (4.0), pero tal vez sea interesante fijarnos en el suelo que pisamos en estos momentos para comprender las necesidades que nos impulsan hacia una evolución fáctica de la Web.

En el tránsito hacia esa supuesta ‘Web Panacea’ descubrimos que tanto la Web 1.0 como la 2.0 poseen limitaciones salvables. La Web 1.0 cumplía con la tarea de relacionar la información de un equipo con la de otro, pero las necesidades humanas requieren de un cuidado más detallado del vínculo inter-personal. De ahí que la Web 2.0 se haya centrado en la sociabilidad de los sujetos conectados.

En definitiva, lo que hemos ido generando es un aumento tanto en las conexiones informativas y de conocimiento, como la ampliación in extenso de la conectividad social.

Pero ahora que parece que todos somos ‘hermanos’ y que nos vinculamos entre nosotros con tan sólo tres clicks, resulta que necesitamos que las máquinas nos acompañen en este proceso de interacción. Para que las computadoras nos faciliten el trabajo y la navegación sea más eficiente es necesario que las máquinas comprendan la información que manejan. La Web Semántica (llamada sin mucho acierto 3.0) es un proceso abierto en el que enseñamos a las computadoras a que sean capaces de entender los contenidos de los flujos informativos, de modo que puedan tomar decisiones favorables para nosotros, sin que tengamos que prestar atención a sus tareas de procesamiento.

En la formación por capas de la Web Semántica podemos hallar las claves de lo apuntado:

- En el Lenguaje de Etiquetado Extensible (XML) los datos no sólo son mostrados, sino que además pueden ser descritos, gracias a su superficie sintáctica.

- El Marco de Descripción de Recursos (RDF) es el primer nivel semántico. Define las clases de dominios de cocimiento usando un vocabulario basado en una semántica formal.

- El Lenguaje Web de Ontologías (OWL)  es el segundo nivel semántico y describe formalmente un dominio de conocimiento.

Todo esto posibilita que se generen lógicas asentadas en una Ontología, que posibilita la clasificación ordenada, por medio de un sistema de conceptos ordenados entre sí.

Ya habrá tiempo para dedicarnos a la Web Ubicua, por ahora aprendamos a madurar la Web Semántica.

NetDrome