Construcción de un sistema multiagente
mediante Jade
•
Curso: Agentes Inteligentes
•
Sevilla, 20 de Mayo de 2008
Gonzalo A. Aranda Corral
Construcción de un sistema multiagente mediante Jade
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/
2
Construcción de un sistema multiagente mediante Jade
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
3
Construcción de un sistema multiagente mediante Jade
Arquitectura básica (Infraestructura)
•Plataforma distribuida
•Comunicación entre plataformas
•Protocolos estándares: Internet
4
Construcción de un sistema multiagente mediante Jade
Arquitectura básica (Plataforma)
•Especificación FIPA
•Agentes y servicios
•Comunicación
5
Construcción de un sistema multiagente mediante Jade
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
6
Construcción de un sistema multiagente mediante Jade
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)
7
Construcción de un sistema multiagente mediante Jade
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
8
Construcción de un sistema multiagente mediante Jade
Creación del proyecto
9
Construcción de un sistema multiagente mediante Jade
Creación del proyecto
10
Construcción de un sistema multiagente mediante Jade
Creación del proyecto
11
Construcción de un sistema multiagente mediante Jade
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.
12
Construcción de un sistema multiagente mediante Jade
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>
13
Construcción de un sistema multiagente mediante Jade
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.”);
}
}
14
Construcción de un sistema multiagente mediante Jade
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)
15
Construcción de un sistema multiagente mediante Jade
Ejecución
16
Construcción de un sistema multiagente mediante Jade
Ejecución
17
Construcción de un sistema multiagente mediante Jade
Ejecución
18
Construcción de un sistema multiagente mediante Jade
Plugin para Eclipse
• http://dit.unitn.it/~dnguyen/ejade/
19
Construcción de un sistema multiagente mediante Jade
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/
SIEMPRE CERRAR
HACIENDO SHUTDOWN
DESDE EL MENU DE LA
PLATAFORMA... SI NO, SE
QUEDA ABIERTA!
---------------------------------------*******************MAS INFORMACION
INFO: -------------------------------------Agent container [email protected]://GON-WS1 is ready.
-------------------------------------------Hola Mundo.
20
Construcción de un sistema multiagente mediante Jade
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.
21
Construcción de un sistema multiagente mediante Jade
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
22
Construcción de un sistema multiagente mediante Jade
Ciclo de vida de un agente
23
Construcción de un sistema multiagente mediante Jade
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.
24
Construcción de un sistema multiagente mediante Jade
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;
}
});
25
Construcción de un sistema multiagente mediante Jade
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;
}
}
26
Construcción de un sistema multiagente mediante Jade
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.
27
Construcción de un sistema multiagente mediante Jade
Implementación de un comportamiento
public class Mensajeria extends CyclicBehaviour {
cíclico
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.
28
Construcción de un sistema multiagente mediante Jade
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
29
Construcción de un sistema multiagente mediante Jade
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.
30
Construcción de un sistema multiagente mediante Jade
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);
}
}
31
Construcción de un sistema multiagente mediante Jade
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é.
32
Construcción de un sistema multiagente mediante Jade
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.
33
Construcción de un sistema multiagente mediante Jade
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.
34
Construcción de un sistema multiagente mediante Jade
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();
}
35
Construcción de un sistema multiagente mediante Jade
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();
}
36
Construcción de un sistema multiagente mediante Jade
Un caso práctico: Tetris
37
Construcción de un sistema multiagente mediante Jade
Tetris: Introducción.
Agente Partida
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
38
Descargar

Construcción de un sistema multiagente mediante Jade