Antecedentes

• Progreso en la programación:
  Código máquina ==> Ensamblador ==> Lenguajes independientes de la máquina (gran mejora en la productividad) ==> Objetos ==> Agentes.

• Computación global:
  ¿Cómo gestionamos miles de procesadores? Asumamos que los modelos actuales no pueden.

• Delegación + Inteligencia:

  • Construcción de sistemas que actúan en lugar de nosotros.
  • Sistemas que funcionen de forma independiente.
  • Deben defender nuestros intereses.

• Interconexión + Distribución:

  • Sistemas que cooperan y llegan a acuerdos
  • Sistemas que compiten

Todo esto no se estudiaba hasta hace «poco» ==> Aparece un nuevo campo: los sistemas multiagente.

Definición de Agente

Un agente representa a un usuario y defiende sus objetivos, intereses y metas.

• «Sistema de computación» = computable
• «De forma independiente» = autónomo
• «A favor de su dueño» = finalidad

Grandes cuestiones a resolver:

• ¿Cómo construirlos? ==> Diseño de agentes.
• ¿Cómo hacer que cooperen? ==> Diseño de sociedades.
• ¿Qué lenguaje usan para comunicarse? ==> Diseño de ontologías.
• ¿Cómo reconocen los conflictos y llegan a acuerdos?
• ¿Cómo se coordinan para alcanzar sus metas de forma cooperativa?

Características

Entornos

Arquitecturas de agentes

def Accion(p: P) -> A:
    conductas = {(c, a) for c, a in R and p in c }
    for (c, a) in conductas:
        if not exists (c1, a1) in conductas or (c1, a1) < (c, a):
            return a
    return None

Comunicación entre agentes

Niveles de comunicación:

• Inferior: método de interconexión de mensajes.
• Medio (sintaxis): formato de la información.
• Superior (semántica): significado de la información.

Tipos de mensajes:

• Planificables vs Servidos por eventos
• Síncronos vs Asíncronos
• Direcciones físicas vs Rol
• Unicast vs Multicast vs Broadcast

Hay varias implementaciones posibles: CORBA, RMI, DCOM…

A mayores se utilizan lenguajes de comunicación: deben tener su semántica bien definida formalmente. Algunas implementaciones son KQML, FIPA ACL, basados en XML, …

Protocolos de comunicación

Un protocolo sería el equivalente a una clase, y una instancia de dicha clase sería un diálogo propiamente dicho.

Cualquier participante en una conversación debe conocer el protocolo que se está utilizando para que la comunicación sea efectiva. Este debe estar definido formalmente e implementado por algún estándar.

Posibles implementaciones:

• FIPA ACL
• Pre- y post- condiciones (Labrou & Finin)

Servicio de transporte

Generalmente, se espera que el servicio de transporte tenga las siguientes características:

• Servicio de confianza: los mensajes llegan a su destino.
• Servicio fiable: se recibe el mensaje tal y cómo se envía.
• Servicio ordenado.
• Permite decidir a los agentes si enviar de forma asíncrona o síncrona.
• Detecta errores si el mensaje está mal formado, el agente no es alcanzable, etc.

Cada agente tendrá un nombre que le permita al servicio remitir el mensaje correctamente. Es capaz de determinar el mecanismo subyacente a utilizar (TCP/IP, HTTP) y permitir cambios en la ubicación del agente.

Asociado a los mensajes, puede haber metainformación y otros parámetros. Esto no se codifica en el cuerpo del mensaje, sino en la interfaz proporcionada para el envío del mensaje.

FIPA ACL

Requisitos

1. Los agentes envía not-understood si no reconocen un mensaje.
   Los emisores deben estar preparados para recibir not-understood de otros.
2. Un agente puede implementar cualquier subconjunto de ACL (mensajes y protocolos).
   Pero dicha implementación debe ser correcta bajo su semántica.
3. Si usa nombres según ACL, deben estar implementados correctamente según su semántica.
4. Los agentes pueden usar otros nombres no definidos, pero son responsables de asegurarse que otros agentes comprenden el significado.
   No deben definir nuevos actos que coincidan con alguno de los estándares.
5. Un agente debe ser capaz de generar mensajes sintácticamente bien formados.
   Debe ser capaz de traducir una secuencia de caracteres a la sintaxis del mensaje.

Modelo de comunicaciones

Generalmente la estructura tiene los siguientes elementos:

• Agente iniciador: manda el mensaje.
• Agente receptor: recibe el mensaje.
• Mensaje: acto comunicativo. Tiene una serie de elementos que forman parte de su metainformación.
  • Tipo: el mensaje puede ser de varios tipos (ver apartado siguiente).
  • Emisor
  • Receptor o receptores
  • Contenido del mensaje propiamente dicho
  • Responder con o En respuesta a sirven para crear hilos de conversación.
  • Ontología
  • Protocolo
  • Conversación

Tipos de mensajes

(   request
    :sender an-agent
    :receiver other_agent
    :content
        (action an-agent
            (search
                (:other-agent-description
                    (:services
                        (:service-type email)))
    :language SL0
    :ontology fipa-agent-management
    :protocol FIPA-request
)

Protocolos

KQML

Knowledge Query and Manipulation Language es otro lenguaje para comunicar actitudes sobre la información, indiferente sobre el formato de la información.

Define la comunicación a 4 niveles:

• Transporte: cómo se envían y reciben los mensajes.
• Lenguaje: qué significa cada mensaje.
• Política: cómo se estructuran las conversaciones (protocolos).
• Arquitectura: cómo conectar los sistemas.

Ontologías

Cómo se representa la información en el mensaje es responsabilidad del programador. Para ello, tiene varias estrategias que puede usar:

• Datos en String (texto)

  • Fácil de leer y comprender por personas.
  • Difícil de leer para la máquina: es necesario parsear sus contenidos.

• Objetos serializables de Java (binario) (java.io.Serializable)

  • No es necesario parsear el mensaje, ya lo hace Java automáticamente.
  • Codificación ilegible para un ser humano.
  • Todos los agentes deben estar implementados en el mismo lenguaje de programación

• Ontología (conjunto de clases)

  • Definir objetos que se pueden traducir a un mensaje ACL y viceversa.
  • Proporciona interoperabilidad entre sistemas multiagente.

Nótese que las secuencias de caracteres o bytes son mejores a la hora de transmitir, pero los objetos son más fáciles de manipular por los agentes.

Una ontología es un diccionario que contiene las definiciones de las palabras y sus sinónimos, para resolver ambigüedades. Se utiliza para representar el conocimiento de distintos universos de discurso.

Problemáticas que resuelven:

• Ambigüedad
  • Uso de diferentes términos para el mismo concepto
  • Uso del mismo término para diferentes conceptos
  • Uso de diferentes sistemas de clases
• Comprensión: múltiples entidades tienen un modelo común del mismo dominio.
• Interoperabilidad: dos entidades que adopten la misma ontología se entenderán entre sí, independientemente del lenguaje de programación y su implementación.

Sin embargo, también plantea el problema del diseño de ontologías: es complejo (sobre todo para dominios inestables y constantemente cambiantes) y altamente dependiente del dominio. Normalmente se diseñan por expertos en el ámbito.

Algunas implementaciones:

• OIL
• Ontolingua
• KIF
• RDF
• Esquemas XML
• DTD

JADE

• Simplifica el desarrollo de estas aplicaciones.
• Completamente compatible con el ecosistema Java.
• Cumple con el estándar de FIPA ==> Interoperabilidad con otros sistemas que también lo implementen.

Implementa las siguientes características:

• Ciclo de vida y movilidad de los agentes.
• Servicio de páginas amarillas y blancas.
• Transporte de mensajes.
• Gestión de las tareas de los agente.
• Conjunto de utilidades para la monitorización y depuración.

Arquitectura

Una aplicación basada en JADE está compuesta de una colección de activos llamados agentes:

• Cada agente tiene un nombre único en todo el sistema (AID). Se usará para poder comunicarse entre sí.
• Forman parte de una red P2P puesto que pueden comunicarse de forma direccional con cualquier otro agente. Sin embargo, los agentes pueden ser heterogéneos (cosa que no son los nodos de una red P2P).
• Viven en un contenedor, el que le proporciona su entorno de ejecución.
• Los contenedores se agrupan en plataformas. En cada plataforma se diferencia un contenedor principal y el resto son secundarios.
• El contenedor principal es aquel que contiene dos agentes especiales desplegados que dan soporte al entorno: el AMS y el DF.

Si se desea mandar un mensaje dentro de la misma plataforma, llega con usar el nombre del agente. Sin embargo, si está en otra plataforma, se le debe añadir el nombre de la plataforma también.

Arranque

jade -cp jade.jar jade.Boot [opciones] [agentes]

Opciones:

• -help
• -container: crea un contenedor y lo enlaza con la plataforma actual.
• -host <hostname>: especifica el host de la plataforma.
• -name <plaform>: especifica el nombre de la plataforma.
• -port <port>
• -gui: lanza el agente de monitorización remota.
• -conf <file>: crea o carga un archivo de configuración.

Especificadores del agente:

<agentname>:<package>.<agentClass>(<params>)

Los parámetros de los agentes se especifican separados por comas (,), y más agentes con puntos y comas (;).

Agentes auxiliares

Programación en JADE

Para programar un agente en JADE, es necesario crear una clase y hacer que extienda de la clase jade.core.Agent:

import jade.code.Agent;

public class MiAgente {
    @Override
    protected void setup() {
        // Inicio del agente

        doDelete(); // Terminar la ejecución del agente
    }

    @Override
    protected void takeDown() {
        // Rutina de terminación del agente
    }
}

• El agente, cuando se ejecuta, llama a setup().
• Para terminar la ejecución, se llama a doDelete().
• Entonces, el agente ejecuta takeDown() y termina.

Cada instancia de un agente se identifica por un jade.core.AID (Agent ID), que se puede obtener con la función Agent.getAID().

• Debe ser globalmente único
• Dentro de una plataforma, solo se identifican por su nombre

AID id1 = getAID();
AID id2 = new AID(localname, AID.ISLOCALNAME);
AID id3 = new AID(name, AID.ISGUID);

• Nombre por defecto de la plataforma: <main-host>:<main-port>/JADE
• Nombre completo del agente: <localname>@<platformname>

Envío de argumentos al agente

Se pueden obtener los parámetros enviados por línea de comandos o desde el agente AMS con la función:

Object[] arguments = getArguments();

Clase Behaviour

El trabajo o tareas que realiza un agente se llaman comportamientos, de la clase jade.core.behaviours.Behaviour.

Se pueden crear nuevos comportamientos extendiendo dicha clase:

• public void onStart(): se ejecuta una vez antes de iniciar el comportamiento.
• public void action(): definición del comportamiento.
• public boolean done(): devuelve true cuando concluye la ejecución del comportamiento.
• public void onEnd(): se ejecuta después de que done() devuelva true. Solo se ejecuta 1 vez.

Cada comportamiento tiene una referencia a su agente a través de la referencia protegida myAgent.

Para ejecutar los comportamientos, se deben añadir a los agentes con Agent.addBehaviour(). Si no hay ninguno para ejecutar, el agente pasa a un estado IDLE y su thread duerme.

Con el método Agent.removeBehaviour() se pueden eliminar comportamientos, pero no se ejecuta onEnd().

Planificación de comportamientos:

• Un agente pude ejecutar comportamientos de forma concurrente.
• El funcionamiento es cooperativo: no se le quita la CPU.
• Sin embargo, todo ocurre en un único Thread de Java.
• Se planifica el siguiente comportamiento cuando el método action() del comportamiento actual termina.

setup()
while True:
    if doDelete():
        break

    b = schedule.getBehaviour()
    b.action()
    if b.done():
        schedule.removeBehaviour(b)
takeDown()

Modelo de comunicación

Los agentes se pasan mensajes de forma asíncrona. Su formato está definido por el estándar de FIPA ACL.

La clase jade.lang.acl.ACLMessage representa un mensaje y proporciona getters y setters a todos los cambios definidos por ACL.

ACLMessage msg = new ACLMessage(ACLMessage.INFORM);
msg.addReceiver(new AID("Peter", AID.ISLOCALNAME));
msg.setLanguage("English");
msg.setOntology("Wheather-Forecast-Ontology");
msg.setContent("Today it's raining");
myAgent.send(msg);

Y para recibir el mensaje:

ACLMessage msg = myAgent.receive();
if (msg != null) {
    // Procesar el mensaje
}

// Bloquear el comportamiento porque no hay mensajes

Es importante bloquear el comportamiento para permitir que otros se puedan ejecutar, dado que el actual no puede continuar porque espera un mensaje.

ACLMessage msg = myAgent.receive();
if (msg == null) {
    block();
    return;
}

// Procesar el mensaje

Alternativamente, también es posible recibir mensajes en modo bloqueante: Agent.blockingReceive().

• El bloqueo termina cuando hay un mensaje en la cola.
• Es peligroso usarlo dentro de un comportamiento:
  • Ningún otro comportamiento podrá ejecutarse.
  • Se recomienda receive() + block()
  • blockingReceive() solo se debe usar en setup() y takeDown() del agente.

Lectura selectiva de mensajes

El método receive() devuelve el primer mensaje de la cola de mensajes y lo elimina. Esto puede suponer un problema cuando hay varios comportamientos esperando mensajes: uno de le puede robar el mensaje al otro.

Para evitar eso, es posible recibir solo los mensajes con determinadas características gracias a jade.lang.acl.MessageTemplate.

MessageTemplate tpl = MessageTemplate.MatchOntology("Test-Ontology");
ACLMessage msg = myAgent.receive(tpl);
if (msg != null) {
    // Procesar el mensaje
    assert msg.getOntology().equals("Test-Ontology");
} else {
    block();
    return;
}

Se pueden combinar varios usando MessageTemplate.or() o MessageTemplate.and().

Servicio de páginas amarillas

El servicio de páginas amarillas permite buscar y/o registrar agentes para que otros puedan localizarlos. El DF es un agente, por lo tanto se comunica con mensajes ACL al igual que el resto de agentes.

La clase DFService proporciona métodos estáticos que ya gestionan el envío de estos mensajes:

• Registrar agente DFService.register(): es necesario especifica una descripción del agente (DFAgentDescription). Esta contiene:
  • El AID del agente
  • Colección de servicios ServiceDescription:
    • Tipo de servicio
    • Nombre del servicio
    • Lenguajes, protocolos y ontologías usados
    • Colección de otras propiedades clave-valor dependientes del servicio
• Desregistrar agente con DFService.deregister().
• Modificar el registro con DFService.modify().
• Buscar agente DFService.search(): se usa un DFAgentDescription con las características a buscar a modo de plantilla.

Ontologías

En JADE, las ontologías se utilizan para representar los elementos que pueden ser usados como contenido de un mensaje ACL.

Se forman de las siguientes partes:

• Una clase derivada de la clase Ontology que define los elementos del dominio y las relaciones entre ellos mediante esquemas.
• Una serie de clases que implementan los esquemas anteriores.

Creación de una Ontología

Para crear una ontología en JADE hay que definir los elementos del esquema y gestionar las expresiones de contenido como objetos Java. Se utiliza el ContentManager para llenar y analizar el contenido de los mensajes.

Los Beans de implementación se utilizan para manipular datos como objetos Java, y si contenido puede variar durante la ejecución.

• Se puede usar la herencia para matizar ciertos aspectos.
• Es buena práctica definir interfaces para modificar la implementación sin cambiar la ontología.
• Sus atributos se conocen como slots: hueco genérico que rellenarán los agentes.

public class Person extends jade.onto.Concept {
    private String name;
    private int age;
    private Person parent;

    public Person() {}
    public String getName() { ... }
    public void setName(String name) { ... }
    // ...
}

Lenguajes de contenido

El siguiente paso es transformar dichos objetos al formato ACL que requiere el estándar. JADE proporciona codecs o lenguajes de contenido para codificar los beans según marca dicho estándar; hay 2 tipos:

Protégé

Diseñar una ontología es complejo y generalmente las crean expertos en el dominio (que no son necesariamente programadores).

Por tanto, se crearon software específico para el diseño de ontologías, como Protégé. OntologyBeanGenerator es un plugin que genera el código Java (los beans y la clase Ontology)

Otros

jade.proto

El paquete jade.proto contiene los comportamientos para el rol de iniciador y el que responde en la mayoría de protocolos de interacción más comunes.

Todas estas clases manejan automáticamente el flujo de mensajes y los timeouts. Proporciona métodos de callback que deben ser redefinidos para tomar las acciones necesarias cuando, por ejemplo, se recibe un mensaje o termina un timeout.

Movilidad

JADE soporta movilidad fuerte: se transfiere tanto el código del agente como su estado (el agente debe ser serializable).

1. Se para la ejecución del agente.
2. Se mueve a un contenedor remoto.
3. Se continua ejecutándose desde el punto exacto donde se detuvo.

Si el código del agente no está disponible en la nueva localización, se recupera bajo demanda.

La migración se inicia:

• Autoiniciada por el propio agente: Agent.doMove().
• Forzada por el AMS, a petición de otro agente.

También se puede clonar con Agent.doClone()

Seguridad

Dado que JADE es un entorno distribuido, hay que tener en cuenta los potenciales peligros:

• Un agente malicioso puede pedir al AMS que mate a otro agente.
• Un agente malicioso puede pedir al AMS que apague la plataforma.
• Una entidad maliciosa puede sniffear o modificar información sensible de los mensajes.

Se previenen los principales problemas utilizando:

• Autenticación y autorización
• Integridad y confidencialidad de punto a punto
• Basado en JAAS (Java Authentication and Authorization Service)

Todos los aspectos de seguridad se implementaron en SecurityHelper, que se puede obtener con Agent.getHelper().

Interfaz con procesos

La clase jade.core.Runtime y el paquete jade.wrapper permiten usar JADE desde un programa externo de Java para crear contenedores y ejecutar agentes.

Comportamientos en Threads

La clase jade.core.behaviours.ThreadedBehaviour permite ejecutar comportamientos normales en un thread dedicado.

Persistencia

Permite guardar y recuperar el estado de un agente de una BD relacional. Todavía es una característica experimental.

Jess y JADE

Jess (Java Expert System Shell) es un sistema experto basado en CLIPS que proporciona una programación basada en reglas y un motor de inferencia para obtener conclusiones a partir de ellas.

La idea de que, en todo momento se tengan que revisar de nuevo todas las reglas que determinen el comportamiento del agente es muy ineficiente.

Para integrar JADE con Jess, se utiliza una clase especial Rete, que implementa el motor de inferencia. Basta con instanciar la clase y manipularlo correctamente.

A continuación, se instancia otro objeto para cargar y parsear la base de conocimiento de un archivo con sintaxis tipo CLIPS. Tras comprobar que es todo correcto, se carga dicha base de conocimientos y se arranca el sistema.

La llamada al método Rete.run() hará que se apliquen todas las comprobaciones y reglas lógicas hasta que no queden más para ejecutar. Esto puede bloquear el hilo del agente, por lo que también se puede usar alternativamente la función Rete.run(MAX_PASSES), que limita el número máximo de pasadas que se hacen por la base de conocimiento.

La idea de esta integración es que el agente reciba estímulos del entorno, añada hechos al sistema experto y reaccione según las reglas con alguna acción. Para ello, puede implementarse desde Jess o implementar la clase Jess.UserFunction.