domingo, 27 de enero de 2008

Comportamientos de los agentes

Un comportamiento es la tarea debe llevar a cabo un agente inteligente. Esta tarea es implementada a través de la clase jade.core.behaviours.Behaviour en donde se encuentran los metodos que permitiran su proceso y terminacion. Para relizar este proceso, la clase que extienda de Behaviour debe implementar los metodos: action() en donde se encontrarán las instrucciones a llevar a cabo por el agente mientras esta activo y done() que debera indicar cuando el comportamiento finalizó el proceso.
La estuctura general de una implementación de un comportamiento sería:

public class ComportamientoCiclico extends Behaviour {
public void action() {
//instrucciones
}
public boolean done() {
return false;
}
}

Para activar el comportamiento de un agente, este debe ser agregado através del metodo addBehaviour() encontrado en la clase Agent.

En JADE, existen por defecto varios tipos de Comportamiento que ya vienen implementados, explicaremos brevemente como funcionan y mostraremos como se implemento uno de ellos en nuestro ejercicio.

  • SimpleBehaviour (Comportamiento Simple): Es un comportamiento atomico que puede ser utilizado en comportamientos compuestos para hacer tareas sencillas (necesita implementar action() y done()).
  • OneShotBehaviour (Comportamiento de Un Tiro): como su nombre lo indica se ejecuta una sola vez.
  • WakerBehaviour (Comportamiento Despertador): se ejecuta una sola vez despues de esperar un tiempo determinado.
  • ReceiverBehaviour (Comportamiento Receptor): se ejecuta cuando un tipo especifico de mensaje ha llegado.
  • CyclicBehaviour (Comportamiento Ciclico): se ejecuta indefinidamente hasta que se programa para detenerse.
  • TickerBehaviour (Comportamiento Periódico): se ejecuta cada N milisegundos.
Existen también comportamientos compuestos que permiten realizar tareas con varios comportamientos de acuerdo a las necesidades, estos se nombran como sub-comportamientos y se agregan a los agentes mediante el metodo addSubBehaviour(); estos comportamientos son:

  • ParallelBehaviour (Comportamiento en Paralelo): realiza procesos de manera concurrente, puede terminar cuando todos los subcomportamientos terminan, cuando cualquiera termina o cuando un numero especifico termina.
  • SequentialBehaviour (Comportamiento Secuencial): ejecuta varios comportamientos de manera secuencial segun se programen y termina cuando el ultimo finaliza su tarea.
  • FSMBehaviour (Comportamiento de Maquinas de Estado): permite definir una Maquina de Estados Finita a traves de subcomportamientos, compuesta por estados inicial, final, intermedios y transiciones, termina cuando el estado final es alcanzado.
Veamos ahora como implementamos en el ejercicio un comportamiento:

Teniendo en cuenta que el AgenteRegulador posee un contenedor al cual debe aumentarle o disminuirle la temperatura dependiendo si esta se ha salido fuera de los limites, el agente verificara periodicamente las condiciones en las cuales se encuentra el contenedor. Estos son los detalles del contenedor :


  • Un nombre que permite identificarlo de manera unica.
  • Una temperatura minima y una maxima que equivalen al rango en el cual debe permanecer la temperatura;
  • La temperatura en la cual se encuentra el contenedor.
  • El intervalo o periodo en el cual se debe aumentar o disminuir la temperatura
  • Una variable que nos indica si el contenedor esta encendido o apagado.
La tarea principal del AgenteRegulador es modificar la temperatura del contenedor de acuerdo al estado en el que este se encuentre (encendido o apagado) cada periodo definido por el usuario para lo cual utilizamos una interfaz en donde se solicitaron los datos.


Por otro lado, el AgenteRegulador tiene que actualizar al AgenteInformante en caso de que haya un cambio, es decir, si se tuvo que apagar o encender el contenedor. El codigo fuente que permite hacer esto es el siguiente:

public class AgenteRegulador extends Agent{

private Contenedor contenedor;
private AgenteReguladorGui miGui;

public void setup() {
//codigo de inicializacion
}

public void iniciarCalentamiento(Contenedor contenedor) {
this.contenedor = contenedor;
contenedor.setNombre(this.getLocalName());
addBehaviour(new ComportamientoRegulador(this));
}

Cuando se llama al metodo iniciarCalentamiento(), este inicia los valores del contenedor y el comportamiento que realizara la tarea. Este comportamiento es del tipo periodico (TickerBehaviour) y el periodo sera el valor que haya ingresado el usuario enla interfaz, los valores se iniciailzan el el constructor en donde se llama al constructor de la superclase (ComportamientoRegulador --> TickerBehaviour).

public class ComportamientoRegulador extends TickerBehaviour {
ACLMessage msgRequest=null;

public ComportamientoRegulador(AgenteRegulador agent) {
super(agent, agent.getContenedor().getIntervalo());
}

El metodo onTick() es donde se ejecutara la tarea cada periodo.
Primero verifica si esta encendido aumenta la temperatura de lo contrario lo disminuye; luego sabe si necesita enviar los datos al AgenteInformante o al AgenteSupervisor segun sea el caso.

@Override
protected void onTick() {

System.out.println("contenedor " + contenedor.isEncendido() + "- " + contenedor.getTemperaturaActual());
if (contenedor.isEncendido()) {
contenedor.setTemperaturaActual(contenedor.getTemperaturaActual() + 1);
} else {
contenedor.setTemperaturaActual(contenedor.getTemperaturaActual() - 1);
}

msgRequest = myAgent.receive();

if (msgRequest != null) {

String contenido = msgRequest.getContent();
System.out.println("contenido Regulador " + contenido + " Sender " + msgRequest.getSender().getLocalName() + " cola " + myAgent.getCurQueueSize());
if (contenido.equals("envieDatos")) {
ACLMessage reply = msgRequest.createReply();

reply.setPerformative(ACLMessage.REQUEST);

String mensaje = "";

if (contenedor != null) {
mensaje = contenedor.getNombre();
mensaje += (";" + contenedor.getTemperaturaActual());
mensaje += (";" + contenedor.getTemperaturaMinima());
mensaje += (";" + contenedor.getTemperaturaMaxima());
mensaje += (";" + contenedor.isEncendido());
mensaje += (";" + contenedor.getIntervalo());
reply.setContent(mensaje);
myAgent.send(reply);
} else {
System.out.println("Contenedor Nulo");
}

} else if (contenido.equals("enciendase")) {
contenedor.setEncendido(true);
informarCambioDeEstado(msgRequest, myAgent);
} else {
contenedor.setEncendido(false);
informarCambioDeEstado(msgRequest, myAgent);
}
}
}
}

//Resto del codigo

}

Creando agentes con JADE

A partir de este momento empezaremso a introducirnos más dentro del framework de JADE y mostraremos a través de un proyecto pequeño realizado dentro del grupo de investigación GICOGE el manejo de las distintas herramientas de JADE para la creación de una plataforma de agentes.

En principio hablaremos de la creación de agentes con JADE. Este proceso es realmente sencillo, teniendo en cuenta que al principio miraremos los elementos básicos para que un agente funcione dentro de la plataforma de JADE. De alguna manera la complejidad de nuestra plataforma de agentes se irá haciendo más evidente a medida que vayamos agregando más características a nuestros agentes, como comportamientos y relaciones con otros agentes.

El proyecto desarrollado consiste en simular un regulador de un contenedor de almacenamiento de cualquier tipo de líquido que necesita mantenerse dentro de una temperatura determinada. Para esto, el regulador debe aumentar o disminuir la temperatura a medida que pasa el tiempo. La temperatura del contenedor debe mentenerse dentro de unos límites tanto superior como inferior de temperatura establecidos por un usuario. Para que el regulador sepa en qué momento debe aumentar o disminuir la temperatura, este debe comunicarse con un agente supervisor que recibirá información constante del estado del agente y del contenedor, de tal manera que basándose en esta información el agente supervisor pueda ordenarle al regulador el aumento o la de la disminusión de la temperatura. Por último, el agente regulador le informará a otro agente, llamado agente informante, todo lo ocurrido en cuanto a su estado y temperatura del contenedor para que este la publique y hacerla visible para el usuario.

Creando un agente:

En principio, la creación de un agente dentro de la plataforma JADE consiste en un proceso sencillo donde nuestro agente hereda de la clase jade.core.Agent e implementar un método llamado setup(). Pero antes de empezar a mostrar la forma práctica hablaremos un poco de la clase Agent:
  • jade.core.Agent: El paquete jade.core contiene el microkernel del sistema de JADE. La clase Agent, que pertenece al paquete jade.core extiende de la java.lang.object y es la superclase que nos permtie crear nuestros agentes dentro de la plataforma JADE. Esta superclase nos proporciona métodos básicos de un agente dentro de JADE como el paso de mensajes utilizando objetos ACLMessage, un ciclo de vida completo que permite los procesos de inicio, suspensión y muerte de un agente y programar y ejecutar varios tipos de actividades concurrentes.

Para explicar la creación de un agente nos basaremos en el proyecto Sistema de Control, en el agente Regulador:

1. Creamos una clase llamada AgenteRegulador que extiende de la clase Agent(No sobra recordar que es necesario importar la librería jade.core.Agent).

import jade.core.Agent;


public class AgenteRegulador extends Agent{
......
}

2. Creamos un método público llamado setup() e inicializamos los siguientes elementos:

  • Interfáz gráfica del agente(no es necesario tener una pero si se va a tener se tiene que inicializar en el setup).
  • Publicación de servicios: Para publicar los servicios que nuestro agente pueda prestar es necesario establecerlos y publicarlos desde el setup(). Debido a que nosotros tenemos varios agentes dentro de nuestra plataforma que necesitan enviar y recibir información de determinados agentes, la plataforma JADE nos permite establecer una descripción del tipo de agente a través de las páginas amarillas o DF, donde podemos publicar un tipo de servicio ofrecido por nuestro agente, de tal manera que cada vez que creemos un agente regulador este tenga un tipo de descripción que facilite su búsqueda y diferenciación dentro de la plataforma.
  •  public void setup() {
    System.out.println("Agente Regulador " + getAID().getName() + " esta listo.");

    miGui = new AgenteReguladorGuiImpl();
    miGui.setAgent(this);
    miGui.show();

    DFAgentDescription dfd = new DFAgentDescription();
    dfd.setName(getAID());
    ServiceDescription sd = new ServiceDescription();
    sd.setType("Calentar-Contenedor");
    sd.setName(getLocalName() + "-Calentar-Contenedor");
    dfd.addServices(sd);
    try {
    DFService.register(this, dfd);
    } catch (FIPAException fe) {
    fe.printStackTrace();
    }

    }

Como podemos observar, al principio de nuestro método, imprimimos en la línea de comando un mensaje con el nombre de nuestro regulador con el cual nos aseguramos de que ha sido iniciado correctamente. Para obtener el nombre de nuestro agente accedemos a través de un método de la clase jade.core.AID. Esta clase extiende de java.lang.object y nos permite utilizar métodos para acceder, establecer, comparar o igualar los distintos elementos del AID de un agente. En este caso utilizamos el método getAID().getName() que nos permite obtener el nombre global de nuestro agente. Esta información también la podríamos obtener con el getAID() de la clase Agent, pero no obtendríamos el nombre global, sino el local.

Para la publcación de nuestros servicios es necesario establecer elementos básicos como el tipo de servicio, el nombre que va a identificar a nuestro servicio, asociarlo a nuestro agente y publicarlo en el DF. Para esto utilizamos los métodos ofrecidos por las clases DFAgentDescription, ServiceDescription del paquete jade.domain.FIPAAgentManagement, y la clase jade.domain.DFService. Publicar nuestros servicios en las páginas amarillas nos facilita que nuestros agentes sean faciltmente encontrados ya que la condición de búsqueda se puede resumir al tipo de servicio que ofrece un agente.

El código general de nuestro agente AgenteRegulador quedaría así en principio:

import jade.core.AID;
import jade.core.AID;
import jade.core.Agent;
import jade.core.behaviours.TickerBehaviour;
import jade.domain.DFService;
import jade.domain.FIPAAgentManagement.DFAgentDescription;
import jade.domain.FIPAAgentManagement.ServiceDescription;
import jade.domain.FIPAException;
import jade.lang.acl.ACLMessage;
import jade.lang.acl.MessageTemplate;
import javax.swing.JOptionPane;
import sistemaDeControl.contenedor.Contenedor;


public class AgenteRegulador extends Agent{

private Contenedor contenedor;
private AgenteReguladorGui miGui;

public void setup() {
System.out.println("Agente Regulador " + getAID().getName() + " esta listo.");

miGui = new AgenteReguladorGuiImpl();
miGui.setAgent(this);
miGui.show();

DFAgentDescription dfd = new DFAgentDescription();
dfd.setName(getAID());
ServiceDescription sd = new ServiceDescription();
sd.setType("Calentar-Contenedor");
sd.setName(getLocalName() + "-Calentar-Contenedor");
dfd.addServices(sd);
try {
DFService.register(this, dfd);
} catch (FIPAException fe) {
fe.printStackTrace();
}

}


}


Aqui encontraras desponible el codigo fuente completo de la aplicacion.
Para NetBeans 5.5 o superior
Descargar

Instalación y configuración de JADE

La plataforma JADE puede obtenerse vía Internet en el sitio oficial http://jade.tilab.com/ en varios tipos de distribución:

Para ejecutar la plataforma es necesario tener la maquina virtual de Java versión 1.5 mínimo.

  • jadeBin.zip – contiene la versión compilada de la plataforma, es decir, el ejecutable listo para usar (jar).
  • jadeDoc.zip – contiene la documentación completa de la plataforma, así como las guías del programador y el administrador (todo en ingles).
  • jadeExamples.zip – contiene código de varios ejemplos.
  • jadeSrc.zip – contiene el código fuente completo de toda la plataforma.
  • jadeAll.zip – contiene todos los paquetes anteriores.

La instalación es muy sencilla, solo basta con guardar los archivos compilados (sea la versión compilada mencionada previamente o una compilación que usted realice) en una carpeta dentro del sistema. La plataforma posee cinco(5) paquetes (jar) para poder ejecutarse: jade.jar, jadeTools.jar, http.jar, iiop.jar que se encuentran en la carpeta jade y commons-codec-1.3.jar que se encuentra en lib/commons-codec-1.3.jar.

La configuración inicial consiste en crear el classpath que permita ejecutar posteriormente los agentes y utilicen los componentes necesarios obtenidos de los paquetes mencionados anteriormente.


Para ubicar el classpath por línea de comandos:

prompt> set JADE_HOME=c:\jade

En donde JADE_HOME indica la ruta donde se ubicaron los paquetes de la plataforma.

prompt> set CLASSPATH=%JADE_HOME%\lib\jade.jar; %JADE_HOME%\lib\jadeTools.jar; %JADE_HOME%\lib\http.jar; %JADE_HOME%\lib\iiop.jar; %JADE_HOME%\lib\commons-codec\commons-codec-1.3.jar; %JADE_HOME%\classes

Para ubicar el classpath por Windows XP:

1. Das clic derecho sobre “Mi PC” y pulsas sobre “Propiedades”.

2. En la pestaña “Opciones avanzadas” pulsas sobre el botón “Variables de entorno”




3. En la sección de Variables del Sistema pulsa en el boton "Nueva" y agrega JADE_HOME en Nombre de variable y en Valor de la variable la ruta en donde se ubicaron los paquetes.

4.
Nuevamenete, en la sección de Variables del Sistema pulsa en el boton "Nueva" y agrega CLASSPATH en Nombre de variable y en Valor de la variable %JADE_HOME%\lib\jade.jar; %JADE_HOME%\lib\jadeTools.jar; %JADE_HOME%\lib\http.jar; %JADE_HOME%\lib\iiop.jar; %JADE_HOME%\lib\commons-codec\commons-codec-1.3.jar; %JADE_HOME%\classes.

5. Pulsa "Aceptar" en las ventanas que quedaron abiertas.

Nota: Si tus carpetas tienen espacios en blanco no olvides ponerlos entre comillas "".

viernes, 21 de diciembre de 2007

Arquitectura JADE


Para la construcción de sistemas distribuidos de agentes, JADE tiene una arquitectura particular en la cual distintos componentes facilitan la creación de estos sistemas. Los componentes que hacen parte de esta arquitectura son los siguientes:





Contenedores(Containers): Son los espacios en los cuales se almacenan los agentes de la AP. Los contenedores proveen procesos para la ejecución de las funciones de JADE para el almacenamiento y ejecución de los agentes. Aunque los contenedores los podemos encontrar distribuidos en toda la red de la AP existe un tipo especial de contenedor, el Contenedor Principal(Main Contanier) que es el primer contenedor creado en una AP y es el encargado de administrar el resto de contenedores que hacen parte de la AP. Una AP tiene un único contenedor principal que permite la creación de nuevos contenedores y la organización de estos al interior de la plataforma. Teniendo en cuenta que el Main Container(MC) es el proceso incial para la construcción de una AP le corresponden unas responsabilidades especiales:





  • Administración de la tabla de contenedores(CT): Todo contenedor posee una referencia al objeto Contenedor y una dirección de transporte para el envío y recepción de mensajes. Estos valores, únicos para cada contenedor, son registrados cada vez que se crea uno en la CT(Container Table) del MC.


  • Administrar la tabla global de descripción de agentes (GADT): Cuando se crea un agente, sin importar el nodo de la plataforma donde fué creado, debe registrar en una única tabla, que se encuentra en el MC, información como su identificación unívoca, el lugar donde se encuentra alojado y su estado acutal.


  • Administración del AMS y el DF: Como primer proceso creado al iniciar una AP, los agentes que facilitan la comunicación dentro de la plataforma en cuanto al servicio de páginas blancas para la ubicación de agentes(AMS) y el servicio de páginas amarillas para la publicación de los servicios prestados por cada agente(DF) son inciados en el MC.


Los contenedores (Containers) también poseen características especiales diferentes a las del MC que permiten el funcionamiento de la AP:





  • Tabla de Descripción de Agentes Locales (LADT): De manera similar al GADT del MC, la LADT permite tener un registro de los agentes creados dentro de un mismo contenedor, como su nombre, identificación, dirección, etc.


  • GADT-Cache: Cuando los agentes necesitan comunicarse con otros agentes, usualmente verifican el LADT para poder obtener la información necesaria para el envío de mensajes, pero cuando estos agentes se encuentran en otro nodo de la plataforma, los agentes deben recurrir al GADT del MC. Para que este proceso no sature al MC de solicitudes al GADT, los contenedores guardan en un espacio llamado GADT-Cache la información de esos agentes encontrados a través del GADT, de tal manera que la próxima vez que un agente necesite comunicarse con otro agente de otro contenedor, primero revisará las comunicaciones pasadas con el fin de encontrar a dicho agente.


Agentes(Agents): Dentro de la AP, los agentes son elementos que viven dentro de los contenedores y son los que constituyen el funcionamiento principal de cualquier AP. Los agentes deben cumplir con unas características espciales para su correcta integración a la AP que en algunos casos ya están establecidos por el estándar de FIPA:





  • Agent Identifier(AID): Representa la identidad el agente dentro de la AP. Está compuesta por un conjunto de campos que cumplen con las especificaciones FIPA. Los elementos principales del AID son el nombre del agente y la dirección de este. El nombre del agente permite identificarlo unívocamente dentro de la AP y está compuesto de la siguiente manera: El nombre local o nickname (con el nickname se puede identificar unívocamente a un agente de manera local, es decir, dentro de una misma plataforma) concadenado al nombre de la plataforma para su identificación de manera global. La direacción del agente es una dirección de transporte heredada de la plataforma que corresponde a un elemento MTP (Message Transport Protocol) de recepción y envío de mensajes que cumplen con las especificaciones FIPA.

martes, 18 de diciembre de 2007

Proyecto JADE-UD




El Proyecto JADE-UD es una propuesta del grupo de investigación de la Universidad Distrital Francisco José de Caldas GICOGE para el desarrollo de sistemas multiagentes basados en el framework JADE(Java Agent DEvelopment Framework) que en el futuro permitan su integración con sistemas de información geográficos.

El Proyecto JADE-UD ha sido iniciado por estudiantes de pregrado de Ingeniería de Sistemas en apoyo a la investigación de los estudianes de maestría en la Universidad Distrital Francisco José de Caldas. En su primera etapa, el proyecto ha buscado generar una documentación en español entorno a la experiencia en el desarrollo de sistemas multiagentes empleando el framework JADE.

Sistemas Distribuidos de Agentes

Antes de empezar con la arquitectura de JADE, hablaremos de los sistemas distribuidos de agentes. Cuando nos encontramos con plataformas distribuidas los elementos principales que la hacen posible forman la estructura básica para cualquier tipo de sistema distribuido sin importar la plataforma de implementación. Estos elementos básicos para el desarrollo de estos sistemas son los siguientes:




  • Plataforma de agentes(Agent Platform): Es la estructura que permite la creación y almacenamiento de todos los agentes del sistema. Esta estructura hace alusión a las máquinas y sus sistemas operativos donde se alojan los componentes de software que permiten la creación y ejecución de los agentes.
  • Agente(Agent): Un agente es un programa autonomo que constituye las plataformas de agentes y que tienen como características como identidad, prestación de servicios y una dirección que le permite recibir mensajes de parte de otros agentes. Dentro de una plataforma estas características se agrupan en dons conceptos: Descripción del Agente y Descripción de los servicios del Agente.
  • Descripción del Agente(Agent Description): Todo agente que haga parte de una plataforma de agentes distribuida debe tener una identificación y dirección únicas, evitando así ambigüedades con otros agentes. Esta información se encuentra almacenada en el AMS.
  • AMS(Agent Management System): El sistema administrador de agentes es un componente principal de una AP(Agent Platform) que lleva a cabo tareas como la creación, elminación, publicación y migración de todos los agentes de la AP.
  • Descripción de los servicios del Agente: A diferencia de la descripción del agente, la descripción de los servicios de este permite identificar la actividad o las actividades que lleva a cabo un agente. Estas actividades no identifican unívocamente al agente y su publicación se debe realizar a través del DF y es responsabilidad del agente hacer esto.
  • Directorio Facilitador(Directory Facilitator): Es un elemento opcional de la AP que funciona como unas páginas amarillas. En el DF(Directory Facilitator) los agentes pueden publicar o retirar sus servicios y encontrar otros que prestan los agentes que hacen parte de la plataforma.
  • Servicio de Transporte de Mensajes(Message Transport Service): Este es un servicio de la AP que permite el envío de mensajes entre agentes dentro y fuera de esta. Como tal, su función es proporcionar una estructura que facilite el envío de la información contenida dentro de un mensaje tipo ACL para que pueda ser recibida y entendida por cualquier agente dentro y fuera de la AP.

JADE Framework



JADE(Java Agent DEvelopment Framework) es un framework desarrollado en Java que nos permite construir sistemas multiagentes cumpliendo con las especificaciones del estandar FIPA(Foundation for Intelligent Physical Agents). JADE nos permite desarrollar sistemas distribuidos de agentes inteligentes, ya que contiene herramientas que facilitan la creación y comunicación de agentes a través de redes sin importar la plataforma (sistema operativo).