sábado, 28 de abril de 2007

Vamos a ver un poco más en profundidad que son cada uno de los principales elementos que conforman una ontología. Para ello nos basaremos en un ejemplo simple que nos permita entender mejor dichos conceptos.

Supongamos que tenemos un sistema de venta de libros en el cual un agente quiere comunicar a otro los libros que oferta. El segundo a su vez quiere ordenar a un tercer agente que compre los libros que elija.

Veamos entonces que elementos compondrán la ontología:

• Conceptos: representas las entidades que forman parte de la ontología, en esta caso la ontología tendrá un concepto que será “Libro”.

• Predicados: son expresiones que relacionan a los conceptos para decir algo. Son necesarios porque un mensaje nunca podremos enviar conceptos, sino que tendremos que enviar predicados o acciones. En el ejemplo usaremos un predicado “Oferta” que indicará que un agente oferta un determinado libro.

• Acciones: son acciones que pueden llevar a cabo los agentes. Para la ontología de libros una acción será “Comprar” que indicará a un agente que debe comprar un determinado libro.

Una vez explicados los distintos elementos, veamos entonces como se implementaría la ontología descrita en JADE:

package librosOntology;

import jade.content.onto.*;
import jade.content.schema.*;

public class librosOntology extends Ontology {
   // Nombre de la ontología
   public static final String ONTOLOGY_NAME = "ontología de libros";

  // Vocabulario de la ontología
  public static final String LIBRO = "Libro";
  public static final String LIBRO_TITULO = "titulo";
  public static final String LIBRO_AUTOR = "autor";
  public static final String LIBRO_PRECIO = "precio";

  public static final String OFERTA = "Oferta";
  public static final String OFERTA_LIBRO = "Oferta_libro";

  public static final String COMPRAR = "Comprar";
  public static final String COMPRAR_LIBRO = "Comprar_libro";

  // Instancia de la ontología
  private static Ontology instancia = new librosOntology();

  // Método para acceder a la instancia de la ontología
  public static Ontology getInstance() {
     return instancia;
   }

   // Constructor privado
   private librosOntology() {
     // librosOntolgy extiende la ontología básica
     super(ONTOLOGY_NAME, BasicOntology.getInstance());

     try {
       // Añade los elementos
       add(new ConceptSchema(LIBRO), Libro.class);
       add(new PredicateSchema(OFERTA), Oferta.class);
       add(new AgentActionSchema(COMPRAR), Comprar.class);

       // Estructura del esquema para el concepto LIBRO
       ConceptSchema cs = (ConceptSchema) getSchema(LIBRO);
       cs.add(LIBRO_TITULO, (PrimitiveSchema) getSchema(BasicOntology.STRING));
       cs.add(LIBRO_AUTOR, (PrimitiveSchema) getSchema(BasicOntology.STRING));
       cs.add(LIBRO_PRECIO, (PrimitiveSchema) getSchema(BasicOntology.INTEGER));

       // Estructura del esquema para el predicado OFERTA
       PredicateSchema ps = (PredicateSchema) getSchema(OFERTA);
       ps.add(OFERTA_LIBRO, (ConceptSchema) getSchema(LIBRO));

       // Estructura del esquema para la acción COMPRAR
       AgentActionSchema as = (AgentActionSchema) getSchema(COMPRAR);
       as.add(COMPRAR_LIBRO, (ConceptSchema) getSchema(LIBRO));
     }
     catch (OntologyException oe) {
       oe.printStackTrace();
     }
   }
}

Como se observa en el código, cada campo de un esquema debe ser de un tipo predefinido, en este caso se usan los tipos primitivos STRING y INTEGER.

Además, cada esquema esta asociado a una clase JAVA, dichas clases se podrían definir tal y como se muestra a continuación:
La clase Libro que implementa el concepto “Libro”, por lo que hereda de Concept:


package librosOntology;

import jade.content.Concept;

public class Libro implements Concept {

   private String titulo;
   private String nombre;
   private int precio;

   public String getTitulo() {
     return titulo;
   }

   public void setTitulo(String t) {
     titulo = t;
   }

   public String getNombre() {
     return nombre;
   }

   public void setNombre(String n) {
     nombre = n;
   }

   public int getPrecio() {
     return precio;
   }

   public void setPrecio(int p) {
     precio = p;
   }
}

La clase Oferta, que implementa un predicado heredando de Predicate:


package librosOntology;

import jade.content.Predicate;

public class Oferta implements Predicate {

   private Libro libro;

   public Libro getLibro() {
     return url;
   }

   public void setLibro(Libro l) {
     libro = l;
   }
}

Y por ultimo la clase Comprar que implementa una acción heredando de AgentAction:

package librosOntology;

import jade.content.AgentAction;

public class Comprar implements AgentAction {

   private Libro libro;

   public libro getLibro() {
     return libro;
   }

   public void setLibro(Libro l) {
     libro = l;
   }
}

Con esto tendríamos definida nuestra ontología para trabajar con ella en JADE. Más adelante veremos como usarla.

viernes, 20 de abril de 2007

Ontologías en JADE

Las ontologías, tal y como se explicó en la anterior entrada, son un mecanismo para representar conceptos que permiten el entendimiento entre dos agentes que establecen una comunicación.

Centrándonos en la comunicación entre agentes de JADE, podríamos pensar que dicha comunicación estaría solucionada con simples intercambios de datos de tipo string. Por ejemplo: si quisiera comunicarle a otro agente que la reunión es "el jueves a las 12:00h en el Hotel Ritz", podría crear un mensaje ACL representado con un string: (Reunion :dia jueves :hora 12:00 :lugar Hotel Ritz).
El verdadero problema de este tipo de comunicación tan simple, es que si quisiéramos obtener directamente la hora o el lugar de la reunión tendríamos que tokenizar el string y recorrerlo de un lado a otro hasta obtener el dato que nos interesa.
Sería más interesante tener la información anterior encapsulada en un objeto Java dentro de un Agente. Posteriormente habría que convertir dicha información en formato de mensaje ACL y a su vez, el agente receptor, debería poder realizar la conversión inversa del mensaje ACL para obtener la información en el formato original. De igual forma, el agente receptor, tiene que poder realizar comprobaciones semánticas para verificar la corrección de dicho contenido con respecto a las reglas de ontología por las cuales los agentes le atribuyen un significado al mensaje intercambiado.

Jade proporciona un soporte para representar lenguajes de contenido y ontologías. Una ontología en Jade no es más que "una colección de esquemas que no cambian durante la vida de un agente". (ref.: Pedro Cuesta Morales; Escola Superior de Enxeñería Informática (Universidade de Vigo); SMProgramacionJADE3.pdf, pág. 6; curso 2006-2007).
Los elementos o esquemas que contiene una ontología en JADE son: los tipos de predicados (Predicates), acciones de los agentes (Agent Actions) y conceptos del dominio de la aplicación (Concepts). Definir una ontología y sus elementos no es más que definir instancias de las clases jade.content.onto.Ontology, para crear un ontología; jade.content.schema.PredicateSchema, para crear un esquema con los tipos de predicado; jade.content.schema.AgentActionSchema, para crear el esquema con las acciones de los agentes; y jade.content.schema.ConceptSchema, para crear el elemento de la ontología que encapsula los conceptos del dominio de la aplicación.

Básicamente esta es la estructura de una ontología en JADE. Queda por explicar con más detalle qué es y cómo se implementa cada elemento de una ontología y el mecanismo para convertir la representación interna de la ontología a la correspondiente expresión de contenido ACL que intercambian los agentes. Esto último es realizado por los códecs, pero será explicado en posteriores entradas del blog.

viernes, 13 de abril de 2007

Definición de Ontología

Para empezar este blog sobre ontologías y agentes vamos a dar una definición de qué es y para qué sirve una ontología.

Lo primero que vamos a ver es la definición de ontología que aparece en la Wikipedia:
El término ontología en informática hace referencia al intento de formular un exhaustivo y riguroso esquema conceptual dentro de un dominio dado, con la finalidad de facilitar la comunicación y la compartición de la información entre diferentes sistemas.
Ésto aplicado a los agentes permiten la comunicación entre aquellos que tengan definida una ontología común para poder entender los conceptos que se intercambian en sus mensajes. Un agente que quiera comunicarse con otros agentes que se muevan dentro de un dominio de aplicación dado (por ejemplo compra-venta de libros), deberá contar con una ontología común a esos agentes que definan los términos que se van a usar (en este caso: libro, editorial, autor, precio, ...).

Para definir estas ontologías se están haciendo esfuerzos para crear un lenguaje estándar para todos los agentes que operan en internet, entre ellos se encuentran el RDF, el DAML o el OWL. Se hablará de ellos en próximas entradas en este blog.