Construcción de un sistema multiagente mediante Jade

1. Construcción de un sistema multiagente mediante Jade • Curso: Agentes Inteligentes • Sevilla, 20 de Mayo de 2008 Gonzalo A. Aranda Corral

2. Java Agent DEvelopment framework • Jade es básicamente dos cosas: • Una plataforma: que permite “VIVIR” y “CONVIVIR” a los agentes dentro de ella. Es decir, proporciona el entorno necesario para la ejecución de estos agentes simultáneamente y los canales para su comunicación y cooperación. • Un conjunto de herramientas con el que realizar el desarrollo de agentes y sistemas multiagente de forma más sencilla, rápida y efectiva. Labor tediosa. • Totalmente realizado en Java. (Portabilidad y Movilidad) • Software libre distribuido por TILAB en código fuente bajo LPGL http://jade.tilab.com/

3. Foundation for Intelligent Physical Agents (FIPA) • Otra de las características más importantes de Jade es el cumplimiento de las especificaciones FIPA • Arquitectura: Esto nos dará muchas ventajas a la hora de la integración de diferentes aplicaciones, incluso con plataformas de diferentes propietarios. • Lenguaje de comunicación empleado FIPA-ACL. • Servicios de agentes: ciclo de vida, páginas blancas, páginas amarillas, transporte de mensajes,... • Conjunto de herramientas gráficas que soportan la depuración y ejecución de agentes (RMA, sniffer, ...) • http://www.fipa.org

4. Arquitectura básica (Infraestructura) • Plataforma distribuida • Comunicación entre plataformas • Protocolos estándares: Internet

5. Arquitectura básica (Plataforma) • Especificación FIPA • Agentes y servicios • Comunicación

6. Arquitectura básica (Agentes) • AMS . Agent Management System: • Garantiza que cada agente en la plataforma tenga un único nombre. • Encargado de proporcionar los servicios de páginas blancas y ciclo de vida, y de mantener el directorio de los identificadores de agentes (AID: Agent Identifier) y su estado. • Cada agente debe registrarse con el AMS para obtener un AID válido • DF . Directory Facilitator: • Agente que proporciona el servicio de páginas amarillas. • Un agente puede encontrar otros agentes que proporcionan los servicios que requiere para cumplir sus objetivos • ACC . Agent Communication Channel: • Software que controla el intercambio de mensajes

7. Cómo obtener Jade • Dirección: http://jade.tilab.com • Para la mayoría de las acciones es necesario registrarse, y aceptar los requisitos de la licencia LGPL • La versión actual de Jade es la 3.6(Mayo 2008), aunque nosotros vamos a realizar este seminario sobre la versión 3.4 (Marzo 2006)

8. Instalación • Descargamos el fichero (JADE-all-3.4.zip) de la versión correspondiente. • Descomprimimos el fichero y nos salen cuatro nuevos ficheros: • JADE-doc-3.4.zip: la documentacion javadoc, el manual del administrador, el del programador y un tutorial. • JADE-src-3.4.zip: el codigo fuente sin compilar. • JADE-bin-3.4.zip: el codigo ya compilado y listo para ser invocado. • JADE-examples-3.4.zip: ejemplos de uso de la plataforma. • Volvemos a descomprimir los 4 ficheros en el mismo directorio. • Se creará un directorio lib/ debajo del cual estarán las librerías necesarias para la ejecución de Jade • NECESITA, al menos, JAVA 1.4.2

9. Creación del proyecto

10. Creación del proyecto

11. Creación del proyecto

12. La clase Agent • Para trabajar con agentes se debe conocer mas o menos a fondo la clase • jade.core.Agent • ya que para crear un agente JADE se debe crear una nueva clase de agente que herede de ésta y que como mínimo implemente el metod setup(). • El método setup() se ejecuta cuando se va a lanzar el agente para su ejecución y únicamente debe contener código relativo a tareas de inicialización. Por lo tanto, de momento, el agente no va a hacer absolutamente nada mas que emitir ese mensaje cuando se lance. • El agente va a permanecer ejecutándose hasta que se invoca el método doDelete(). Este método llama a su vez a takeDown() que podéis redefinir para incluir código relativo a limpieza de elementos del agente. • El método getArguments() devuelve un Object[] que proporciona los argumentos que se le han pasado al agente. Para que no haya ningún problema, el lector de los argumentos debe saber el numero y el tipo de cada uno de los argumentos.

13. Identificadores de agentes • En JADE, la descripción del agente, el AID (Agent Identier) tiene su correspondiente clase java, • jade.core.AID • a partir de la cuál se pueden manejar las características básicas del agente • La clase Agent incorpora el método getAID() que permite recuperar el nombre del agente. El nombre del agente, un identificador único globalmente(normativa FIPA), va a tener la estructura • <nickname>@nombre-plataforma>

14. El primer Agente • Creamos nuestro primer agente cuya función va a ser saludar al mundo. import jade.core.Agent; public class JAgente extends Agent { protected void setup() { System.out.println(“Hola Mundo.”); } }

15. Ejecución • Para la ejecucion de Jade, lo podemos realizar de dos formas distintas: • Desde la linea de comandos: • java <classpath> [opciones] jade.Boot agente:ClaseAgente • classpath: direccion y nombre de los *.jar de Jade • opciones: en principio, solo vamos a usar la opcion “-gui” para mostrar el interface grafico de Jade • jade..Boot: es la clase de arranque de la plataforma • agente:ClaseAgente: Nombre y clases(incluyendo paquetes) de donde queremos crear el agente • Desde Eclipse: • Creamos un proyecto y ponemos los siguiente paramentros (Ver pag siguiente)

16. Ejecución

17. Ejecución

18. Ejecución

19. Plugin para Eclipse • http://dit.unitn.it/~dnguyen/ejade/

20. Traza SIGUE VIVO!!! 25-may-2006 1:46:38 jade.core.Runtime beginContainer INFO: ---------------------------------- This is JADE 3.3 - 2005/03/02 16:11:05 downloaded in Open Source, under LGPL restrictions, at http://jade.cselt.it/ ---------------------------------------- *******************MAS INFORMACION INFO: -------------------------------------- Agent container Main-Container@JADE-IMTP://GON-WS1 is ready. -------------------------------------------- Hola Mundo. SIEMPRE CERRAR HACIENDO SHUTDOWN DESDE EL MENU DE LA PLATAFORMA... SI NO, SE QUEDA ABIERTA!

21. Comportamientos • Los agentes realizan las acciones y las percepciones mediante los “Comportamientos”. • La clase(y paquete) principal de los comportamientos es: • jade.core.behaviours.Behaviour • La clase Behaviour tiene 2 métodos principales: • action(): que es el método que se ejecuta cada vez que se invoca el método • done(): hace la comprobación de si el comportamiento ha terminado o no.

22. Comportamientos • Un comportamiento tipo sería: public class CSimple extends Behaviour { public void action() { while (true) { // Acciones a realizar } } public boolean done() { return true; } } OJO: Este comportamiento bloquearía el sistema

23. Ciclo de vida de un agente

24. Comportamientos • El funcionamiento de los comportamientos está implementado a 2 niveles: • Una cola circular de los comportamientos activos • Una cola con los comportamiento bloqueados. • Los comportamientos se desbloquean al recibir el agente un mensaje.

25. Comportamiento(II) • Lanzar el comportamiento • para añadir un comportamiento a un agente usaremos el método “addBehaviour()” que lo podremos llamar de la siguiente forma: • (dentro de la clase agente, todavía) this.addBehaviour(new Behaviour() { int contador = 12; public void action() { // ACCIONES A REALIZAR System.out.println(contador); contador--; } public boolean done() { // CONDICION DE FINAL DE COMPORTAMIENTO return contador == 0; } });

26. Comportamiento(III) o creando un objeto y activándolo miPrimerComportamiento comporta = new miPrimerComportamiento(); this.addBehaviour(comporta); con la clase “miPrimerComportamiento” creada anteriormente, ya sea como clase privada dentro del fichero o como pública en un fichero aparte class miPrimerComportamiento extends Behaviour { int contador = 10; public void action() { // ACCIONES A REALIZAR System.out.println("\t" + contador); contador--; } public boolean done() { // CONDICION DE FINAL DE COMPORTAMIENTO return contador == 0; } }

27. Tipos de comportamientos • Dentro de Jade, vienen implementado diferentes comportamientos listos para ser usados. Son los siguientes: • Behaviour: Comportamiento genérico. • OneShotBehaviour: El método done() siempre devuelve “true”, de forma que solo se ejecuta una vez y de forma ininterrumpida. • CyclicBehaviour: El método done() siempre devuelve “false”, de forma que está siempre ejecutándose. Esto puede tener el peligro de quedarse con toda la CPU. • TickerBehaviour: Comportamiento que se ejecuta periódicamente cada cierto tiempo(dado en el constructor). • .............. • Los comportamientos además se pueden componer y formar comportamientos más complejos. • Una implementación interesante sería el comportamiento BDI dentro de Jade.

28. Implementación de un comportamiento cíclico public class Mensajeria extends CyclicBehaviour { private int estado = 0; public void action() { ACLMessage mensajes = myAgent.receive(); if (mensajes != null) { switch(estado) { case 0: // Llega una peticion de partida nueva case 1: break; } } else { block(); } } } Los comportamientos cíclicos se suelen implementar como una máquina de estados, y con bloqueos a la espera de recibir mensajes.

29. Mensajería • La capacidad de comunicación de un agente viene soportada por el envío de mensajes ACL. • En un mensaje podremos distinguir 4 partes principales: • Receptor y Emisor • Contenido • Directiva • Lenguaje y Ontologías • El mensaje es un objeto de la clase jade.lang.acl.ACLMessage y cuando se crea el mensaje, invocando al constructor, le pasamos un parámetro que es la “PERFORMATIVA” • Además, el mensaje posee otros parámetros para identificar los mensajes, como ReplyWith, ConversationId, etc

30. Mensajería • El envío de mensajes lo deberemos de realizar dentro de los comportamientos. Estos comportamientos podrán ser OneShot o Cyclic, dependiendo de lo que nos interese. • Los comportamientos cíclicos se realizan para la recepción de mensajes, ya que los podemos bloquear hasta la recepción de uno nuevo. • En el Agente Jugador, tendríamos un comportamiento de disparo para solicitar que empiece la partida. • Todas las acciones de un agente, deben de estar implementadas como comportamientos.

31. Mensajería package Jugador; import jade.core.AID; import jade.core.behaviours.OneShotBehaviour; import jade.lang.acl.ACLMessage; public class MEmpezar extends OneShotBehaviour { public void action() { ACLMessage mensaje = new ACLMessage(ACLMessage.REQUEST); AID partida = new AID("miPartida",AID.ISLOCALNAME); mensaje.addReceiver(partida); mensaje.setContent("Quiero Jugar"); myAgent.send(mensaje); } }

32. Mensajería • Dentro de Jade, y haciendo uso de las directivas, se han implementado diferentes protocolos, que sólo vamos a nombrar ya que se escapan de nuestro alcance. • FIPA Request Interaction Protocol Specification • FIPA Query Interaction Protocol Specification • FIPA Request When Interaction Protocol Specification • FIPA Contract Net Interaction Protocol Specification • ... • El lenguaje de contenido FIPA es el SL, que es un lenguaje con una sintaxis muy parecida al LISP, aunque no está demás recordar que FIPA lo que tiene son RECOMENDACIONES. • También se puede hacer uso de ontologías, que podemos crear con programas como Protégé.

33. Registro y búsqueda • Los agentes se pueden registrar en las plataformas para ser buscados (*) • “No tenemos por que saber como se llama el agente que posee nuestra partida” • Aunque al menos tiene que existir lo que se denomina: “El secreto compartido”, es decir, tenemos que saber ALGO de lo que queremos buscar. En nuestro caso es el nombre de los dos agentes especiales AMS y DF • El registro dentro del servicio de páginas blancas es obligatorio para pertenecer a la plataforma. • El registro en las páginas amarillas es opcional. En él se registran los servicios que ofrece cada agente, pudiéndose dar más de una entrada por agente.

34. Registro en Páginas Blancas • Se realiza automáticamente al unirse a la plataforma. • Se puede realizar “a mano” si se desea, • Si extendemos de la clase Agent, esta lo tiene implementado.

35. Registro en Páginas Amarillas //----------------------------------------------------------------// // Registrar el Creador en el facilitador de directorio //----------------------------------------------------------------// DFAgentDescription dfd = new DFAgentDescription(); dfd.setName(getAID()); ServiceDescription sd = new ServiceDescription(); sd.setType("Crear"); sd.setName("Creacion"); dfd.addServices(sd); try { DFService.register(this,dfd); cad.println("Creador\t\tRegistrado"); } catch(FIPAException fe) { fe.printStackTrace(); }

36. Búsqueda de servicios DFAgentDescription template = new DFAgentDescription(); sd = new ServiceDescription(); sd.setType("Traducir"); template.addServices(sd); AID[] creadores = null; try { DFAgentDescription[] result = DFService.search(this,template); creadores = new AID[result.length]; for (int i=0; i< result.length; i++) { creadores[i] = result[i].getName(); } } catch (FIPAException fe) { creadores = null; fe.printStackTrace(); } if (creadores == null) { this.doDelete(); }

37. Un caso práctico: Tetris

38. Agente Partida Tetris: Introducción. Sistema Multi-agente (2) que van a interactuar por medio de mensajes ACL para implementar el juego del Tetris Jade nos ofrece la facilidad de implementación rápida de comportamientos y la exportabilidad, casi inmediata, a un funcionamiento en red. Agente Jugador