Sistemas Inteligentes

David Ruano Ordás

Departamento de Informática
[email protected]
Despacho 409
Contenidos
● Agentes inteligentes
● BDI (Belief - Desire - Intention)
○ Creencias (Beliefs)
○ Deseos (Desires)
○ Intenciones (Intentions)
● Sintaxis en AgentSpeak
● Estructura en AgentSpeak
○ Estructura de los agentes.
○ Comunicación entre agentes.
Agentes inteligentes

Un agente inteligente es un sistema informático situado en un entorno, que es capaz de

actuar de forma autónoma y flexible con el fin de cumplir los objetivos que se le han asignado.

Sin la intervención del ser humano.

Elegir: Implica:
+ La acción(es) que debe realizar + Reactivo: interaccione con el entorno y responda a
- Que realizar posibles cambios que puedan suceder.
+ El momento en el que realizará la acción(es) + Proactivo: tener la intención de alcanzar los objetivos.
- Cuando realizarlo + Sociable: interactuar y cooperar con otros agentes
(o humanos) mediante un lenguaje de
comunicación
BDI (Belief, Desire, Intentions)
● Creencias: es la información que el agente tiene sobre el mundo.Puede ser:
○ Información que el agente ya tiene incluida en la base de creencias. creencias

○ Información que obtiene de la comunicación con otros agentes. hechos reglas

○ Ejemplo: supongamos que tempReactor almacena la temperatura de
un reactor nuclear. afirmaciones que el afirmaciones sobre
agente considera ciertas relaciones entre hechos
variable ← tempReactor → creencia
lenguaje programación “tradicional” AgentSpeak
● Deseos: son todos los posibles estados que el agente podría desear realizar.
○ No implica que el agente actúa en consecuencia → influye en la acciones del agente.
○ Puede haber deseos incompatibles entre sí.
○ Conceptualmente: deseos → metas.
● Intenciones: son el conjunto de acciones que el agente decide hacer. Pueden ser:
○ Objetivos previamente asignados.
○ Elección entre las opciones disponibles: examina las opciones existentes y elige Ir al segundo piso Deseos

la(s) más adecuada(s).

■ Opciones elegidas → intenciones
○ Las intenciones se realizan a través de la ejecución de planes
Subir por las Subir por el
Intenciones escaleras ascensor
 Sintaxis en AgentSpeak
● AgentSpeak posee tres construcciones lingüísticas:
○ Beliefs definition (definición de creencias).
○ Desires definition (definición de deseos).
○ Plans definition (definición de planes).
● La arquitectura de AgentSpeak tiene cuatro componentes principales:
○ Belief Base: conjunto de creencias que posee el agente.
○ Plan library: conjunto de métodos que permite definir los planes que tiene el agente.
■ Plan: pasos para realizar un objetivo.
○ Set of events: conjunto de reacciones que tiene un agente tras ejecutar los planes.
○ Set of intentions: conjunto de acciones que el agente desea/puede realizar (intenciones).

// Agent sample in project example

Base de creencias iniciales.
/* Initial beliefs and rules */ Creencia → información que el agente “conoce”
Creencia → Puede producir/usarse en los deseos.
Conjunto de deseos del agente. Creencias
/* Initial goals */ Deseo → acciones que el agente quiere/puede realizar. Deseos Planes
Deseo → invocan a los planes OJO: Un plan
puede llamar a
/* Plans */ Conjunto de planes que el agente puede ejecutar. otro plan !!
Plan → conjunto de pasos para satisfacer un deseo.
Estructura Agente en AgentSpeak Flujo de operaciones en AgentSpeak
 Sintaxis en AgentSpeak
● Creencias (Agent’s Beliefs)

Ejercicio: Dada la siguiente Base de Creencias, ¿Que conocimiento sería capaz de inferir el agente?

Base de Creencias //Hechos //Hechos inferidos

parent(eric, bob). //Hechos
child(bob,eric)
parent(eric, bob). //Hechos parent(bob, jane). female(jane).
child(jane,bob)
parent(bob, jane). parent(bob, john). male(john).
child(john,bob).
parent(bob, john).
female(jane). //Reglas
//Reglas grandparent(X,Z) :- daughter(X,Y) :-
male(john). son(X,Y) :-
child(X,Y) :- parent(Y,X). parent(X,Y) & parent(Y,Z). child(X,Y) & female(X).
child(X,Y) & male(X).
child(X,Y) :- parent(Y,X). //Reglas
grandparent(X, Z) :- parent(X,Y) & parent(Y,Z). child(bob,eric).
grandparent(eric, jane).
son(X,Y) :- child(X,Y) & male(X). child(jane,bob). son(john,bob). daughter(jane,bob).
grandparent(eric,bob).
daughter(X,Y) :- child(X,Y) & female(X). child(john,bob).
1 2
3

parent(eric, bob). //Hechos Base de Creencias

parent(bob, jane).
parent(bob, john).
child(bob,eric). //Hechos inferidos
female(jane).
child(jane,bob).
male(john).
child(john,bob).
child(X,Y) :- parent(Y,X). //Reglas grandparent(eric, jane).
grandparent(X, Z) :- parent(X,Y) & parent(Y,Z). grandparent(eric,bob).
son(X,Y) :- child(X,Y) & male(X). son(john,bob).
daughter(X,Y) :- child(X,Y) & female(X). daughter(jane,bob).
Sintaxis en AgentSpeak
● Creencias (Agent’s Beliefs).
○ Anotaciones: lista de términos entre corchetes inmediatamente después de la fórmula.
■ Se utilizan para recoger/restringir las fuentes de información.
■ Tipos de anotaciones:
● source(s): indica cual es el origen (s) de la información.
s = indica el nombre de un agente.
s = percept → indica que la creencia surge de la percepción del entorno (algo sucede).
s = self → que el agente añade explícitamente una creencia a su propia base de creencias.
● Personalizadas por el usuario
Anotación personalizada

Ejemplo: Dada la siguiente Base de Creencias de John

colour(box,blue)[source(bob)]. colourblind(bob)[source(self), degOfCert(0.7) ].

● John conoce que el color de la caja es azul porque se lo dijo bob Conclusiones ● Bob es daltónico (con una probabilidad del 70%)
~colour(box,white)[source(john)]. lier(bob)[source(self), degOfCert(0.2) ].
● John ya tiene el conocimiento de la que la caja no es blanca ● O bien, bob es un mentiroso (con una probabilidad del 20%).
colour(box,red)[source(percept)]. mistake(bob)[source(self), degOfCert(0.1)].
● John percibe del entorno (ej. cámara de video) que la caja es roja Conclusiones ● O bien, bob se ha equivocado (con una probabilidad del 10%)
Contradicción!!
Sintaxis en AgentSpeak
● Deseos (Agent’s Goals)
○ Existen dos tipos de deseos:
■ Achievement: representan las acciones que el agente quiere alcanzar.
● Se definen con el carácter “!”.
■ Test: representan información que el agente quiere conocer → consulta en la Base de Creencias
● Se definen con el carácter “?”.

Ejemplo: Test Goals vs Achievement Goals

//Base de creencias de Alice

saludo(Agent,”Hola”,”Agent”, cómo estás”). Alice tiene dos formas de saludo dependiendo
saludo(john,”Hey, John que tal?”). de si es john u otro agente.

//Deseos
Achievement Goal !saludar(john). Alice desea realizar la acción de saludar a john

//Planes
Para poder cumplir el deseo de saludar a john,
+saludar(john) : true <-
Alice debe buscar en la lista de planes el plan
?saludo(john,Msg).
buscar en la base que le permita saber como hacer para saludar a
Test Goal +saludar(A) : true <-
de creencias john
?saludo(A,Msg).
Sintaxis en AgentSpeak
● Planes (Agent’s Plans)
○ Conjunto de pasos (acciones) que permiten realizar un evento.
○ Está formado por tres partes: triggering_event, context y body:
○ Las partes están separados por los símbolos : y <-:
triggering_event : context <- body .

+ Representan cambios en: + Define las condiciones que se + Define los pasos (o conjunto de pasos) que se
● Creencias (beliefs) han de cumplir para que se deben realizar para la consecución del plan
● Deseos (goals). aplique un plan.
+ Dos tipos de eventos: + Condiciones se pueden
● Creación combinar usando &, |
● Eliminación + Permite discernir entre planes.
Sintaxis de todos los tipos Sintaxis para todos
de eventos existentes los tipos de contextos

Notación Descripción Notación Significado

+<<event>> Añadir una creencia c Agente sabe que la condición c es cierta Se comprueba sobre la Base de Creencias
-<<event>> Eliminar una creencia ~c Agente sabe que la condición c es falsa
+!<<event>> Añadir un Achievement Goal not c Agente no sabe que la condición c es cierta La creencia no debe estar en la Base de Creencias.
-!<<event>> Eliminar un Achievement Goal not ~c Agente no sabe que la condición c es falsa + Si está en la BC entonces siempre será falsa.
+?<<event>> Añadir un Test Goal
-?<<event>> Eliminar un Test Goal

○ Plan labeling: etiquetar un plan permite acceder al plan por el nombre de la etiqueta.
■ Sintaxis: @plan_name
Sintaxis en AgentSpeak
● Planes (Agent’s Plans)
○ Ejemplo: comportamiento de la negación (~) y negación por prueba (not ~).
Dada la siguiente base de creencias

Base de Creencias child(bob,eric).

//Hechos inferidos
child(jane,bob).
parent(eric, bob). //Hechos child(john,bob).
parent(bob, jane). grandparent(eric, jane).
parent(bob, john). grandparent(eric,bob).
female(jane). son(john,bob).
male(john). daughter(jane,bob).
[1]
¿Cuál es el resultado de evaluar las siguientes sentencias? Se ejecutará el
plan cuando el
+ La creencia debe estar en la BC. agente no sepa si
son(john, bob) +!salir(casa) : not sol & not ~sol
+ La creencia está definida como verdadera hace sol o no
<- ir_ubicacion(ventana_salon);
?tipo_cortinas(Ventana); Ejecutar el plan [2]
+ La creencia no debe estar en la BC.
not female(jane) abrir(Ventana) ; ir_ubicacion que
+ La creencia está en la BC. .... . indicará las
+ Se hace la comprobación sobre la BC. acciones para que
~ male(john)
+ La creencia está definida como falsa. [3] Recuperar de la BC el tipo el agente vaya a la
de cortinas que tiene la ventana_salon
not son(bob, brian) ventana del salón
+ La creencia no debe estar en la BC.
+ La creencia no está en la BC Ejecutar el plan abrir que
+ No hay información sobre la creencia [4]
not ~ son(bob, brian) le indique al agente las
acciones necesarias para
abrir las cortinas de la
ventana_salón
Estructura en AgentSpeak
● Estructura de los Agentes

// Agent sample_agent in project example

/* Initial beliefs and rules */ Base de creencias iniciales.

Creencia → información que el agente “conoce”
→ Puede producir deseos (metas).
/*
/* Initial
Initial goals
goals */
*/
Conjunto de metas del agente.
Deseos → acciones que el agente desea/puede realizar.
/*
/* Plans
Plans */
*/
Conjunto de planes que el agente puede ejecutar.
Plan → conjunto de pasos para satisfacer una meta.

Creencias
Deseos Planes
OJO:
Un plan puede
llamar a otro plan !!
 Sintaxis en AgentSpeak
● Ejemplo: calcular el factorial de 5 (caso 1).

// Agent sample in project factorial

/* Initial beliefs and rules */

fact(0,1). Base de creencias iniciales.
El agente sabe que el factorial de 0 es 1.
/*
/* Initial
Initial goals
goals */
*/
Conjunto de metas del agente.
No hay ninguna meta a alcanzar.
/*
/* Plans
Plans */
*/
+ definir nueva creencia + fact(N,F) : N < 5 <- Conjunto de planes que dispone el agente.
+fact(N+1,(N+1)*N) . +fact(N,F) → dos planes diferentes:
Llamada recursiva N<5: crea nuevas creencias mientras N sea menor que 5
+ fact(N, F) : N == 5 <- N==5: imprime el resultado cuando N == 5
.print(“Factorial de ”,N,” es “,F) .

Estructura condicional.
Se ejecuta el plan sólo si se cumple la condición
Útil para distinguir entre planes con el mismo nombre
¿Problema?

El agente añade una creencia por cada llamada recursiva

(por eso se usa el símbolo ‘+’ en la llamada).
Incremento innecesario de la base de creencias.
Lenguaje Jason
● Ejemplo: calcular el factorial de 5 (caso 1).

Todas las creencias

añadidas a la BD de
creencias necesarias
para calcular
Resultado de la ejecución del agente. factorial de 5

Estado interno del agente

Estructura en AgentSpeak
● Ejemplo: calcular el factorial de 5 (caso 2).

// Agent sample in project factorial

/* Initial beliefs and rules */

Base de creencias iniciales.
El agente no tiene conocimiento previo.
/* Initial
/* Initial goals
goals */
*/
Definición de la meta ! print_fact(5). Conjunto de metas del agente.
!print_fact(5) → la meta del agente es calcular el factorial de 5.
/*
/* Plans
Plans */
*/
+! →definir el plan + !print_fact(N) <-
!fact(N,F) ;
.print(“El factorial de ”,N,” es “F).
Llamada a otro plan
+ !fact(N,1) : N == 0. Conjunto de planes que dispone el agente.
+ !fact(N,F) : N > 0 <- +!print_fact(N) → indica los pasos para calcular el objetivo del agente.
Llamada recursiva !fact(N-1,F1) ; +!fact(N,1) → este plan será ejecutado cuando N = 0
+!fact(N,F) → este plan será ejecutado cuando N > 0
F = F1 * N.

Estructura condicional.
Se ejecuta el plan sólo si se cumple la condición
Útil para distinguir entre planes con el mismo nombre
Lenguaje Jason
● Estructura de los agentes
○ Ejemplo: calcular el factorial de 5 (caso 2).

Sólo está la creencia

inicial.
No se añadieron
nuevas creencias para
Resultado de la ejecución del agente. realizar el cálculo

Estado interno del agente

Sintaxis en AgentSpeak
● Comunicación entre agentes

○ La comunicación entre agentes se realiza mediante paso de mensajes.

■ Uso del lenguaje KQML (Knowledge Query and Manipulation Language) R
○ Dos tipos de funciones internas para la comunicación:
S
<s, p, c>
.send(receptor, performative, content)
T
Envío del mensaje a un agente (o conjunto de agentes) determinado .send(r, p, c)

S
.broadcast(performative, content) <s, p, c>

Envío del mensaje a todos los agentes definidos en el entorno .broadcast(p, c) T

<s, p, c>
Sintaxis en AgentSpeak
● Comunicación entre agentes

Indica la acción (intención) a realizar. Existen 9 tipos:

+ tell → informa al receptor de que la sentencia en content está en la BC del emisor.
+ untell → informa al receptor de que no cree la sentencia en content (eliminar de BC receptor).
+ achieve → solicita al receptor que intente alcanzar un estado en el mundo en el que content sea verdadero.
+ unachieve → revertir el efecto en el receptor de un mensaje enviado previamente de tipo achieve.
+ askOne → emisor solicita conocer si la sentencia en content está en la BC del receptor.
+ askAll → emisor solicita conocer todas las respuestas en la BC del receptor para la sentencia en content.
+ tellHow → informa al receptor sobre un plan (plan existente en el emisor).
+ untellHow → solicita al receptor que elimine el plan indicado en la sentencia content.
+ askHow → solicita al receptor todos los planes que sean compatibles con el evento indicado en content.
+ ....

.send(receptor, performative, content)

Indica nombre(s) del(os) agente(s) al que se le envía Es una frase que puede contener:
el mensaje. + Un literal (o conjunto de literales)
+ a1 → si el receptor es el agente a1 + Un plan (o conjunto de planes)
+ [a1,a2] → si los receptores son el agente a1 y a2. + Un evento (o conjunto de eventos)
Sintaxis en AgentSpeak
● Comunicación entre agentes
○ Ejemplos: tell vs untell.

+ La creencia open(door)[source(s)] se añade a la BC de r

.send(r, tell, open(door))
+ El agente r pasará a creer que la puerta está abierta.

CONSTANTE

+ La creencia open(door)[source(s)] se eliminar de la BC de r

.send(r, untell, open(door))
+ El agente r dejará de creer que la puerta está abierta.

CONSTANTE
S R

1 Acciones 2 Eventos 3 Base de Creencias

.send(r, tell, open(door)) +open(door)[source(s)]
open(door)[source(s)]

.send(r, untell, open(door)) -open(door)[source(s)]

S R
Sintaxis en AgentSpeak
● Comunicación entre agentes
○ Ejemplos: achieve vs unachieve.

+ Se crea el evento +!open(door)[source(s)], y se añade al conjunto de eventos de r.

.send(r, achieve, open(door))
+ Si existe un plan para ese evento en r, el agente intentará ejecutarlo→comprometerse.

CONSTANTE

.send(r, unachieve, open(door)) + Se borra el evento +!open(door)[source(s)], del conjunto de eventos de r.

CONSTANTE
S R

1 Acciones 2 Eventos 3 Intenciones

.send(r, achieve, open(door)) +!open(door)[source(s)]
!open(door)[source(s)]

.send(r, unachieve, open(door)) -!open(door)[source(s)]

S R
Sintaxis en AgentSpeak
● Comunicación entre agentes ASÍNCRONO
○ Ejemplos: askOne vs askAll (NO BLOQUEANTE)

+ Agente s pide a r si tiene alguna creencia sobre cómo abrir una puerta cualquiera.
.send(r, askOne, open(Door)) + Si r tiene más de una creencia → envía la primera creencia de la BC a s.
+ Si r tiene una única creencia → envía la creencia a s.
VARIABLE + Si r no tiene ninguna creencia:
- Agente r tiene algún plan para obtenerla → lo ejecuta y envía la creencia a s
- Agente r no tiene un plan para obtenerla → envía false.

.send(r, askAll, open(Door)) + Mismo comportamiento que askOne pero si r tiene más de una creencia que encaja →
envía todas las creencias de la BC a s.
VARIABLE
S R Base de Creencias
open(window)
open(door)

3 Eventos 1 Acciones 2 Acciones

.send(r, askOne, open(Door))
+open(window)[source(s)] .send(s, tell, open(window))

.send(r, askAll, open(Door))

+open(window)[source(s)] .send(s, tell,[open(window),
+open(door)[source(s)] open(door)])

S R
Sintaxis en AgentSpeak
● Comunicación entre agentes SÍNCRONO
○ Ejemplos: askOne vs askAll (BLOQUEANTE)

+ Agente s pide a r si tiene alguna creencia sobre cómo abrir una puerta cualquiera.
.send(r, askOne, open(Door), Reply) + Si r tiene más de una creencia → envía la primera creencia de la BC a s.
+ Si r tiene una única creencia → envía la creencia a s.
VARIABLE + Si r no tiene ninguna creencia:
- Agente r tiene algún plan para obtenerla → lo ejecuta y envía la creencia a s
- Agente r no tiene un plan para obtenerla → envía false.

.send(r, askAll, open(Door), Reply) + Mismo comportamiento que askOne pero si r tiene más de una creencia que encaja →
envía todas las creencias de la BC a s.
VARIABLE
S R Base de Creencias
open(window)
open(door)

3 Eventos 1 Acciones 2 Planes

.send(r, askOne, open(Door), Reply)
Reply ↦ open(window)[source(s)] .send(s, tell, open(window))

.send(r, askAll, open(Door), Reply)

Reply ↦ [open(window)[source(s)], .send(s, tell,[open(window),
open(door)[source(s)] open(door)])

S R
Sintaxis en AgentSpeak
● Comunicación entre agentes
○ Ejemplos: tellHow vs untellHow

.send(r, tellHow, ”@p1 +!open(Door): not locked(Door) + Agente s le envía a r el plan @p1 (contiene los pasos/órdenes que debe realizar).
<- turn_handle(Door); push(Door); ?open(Door).”) + El plan indica los pasos para abrir la puerta si no está cerrada con llave
- Girar la manilla
- Empujar la puerta
- Recuperar de la BC el tipo de puerta y eliminar la meta.

.send(r, untellHow, “@p1”, Reply) + Agente s le dice a r que elimine el plan @p1 de su librería de planes

S R

1 Acciones 2 Planes
.send(r, tellHow, ”@p1 +!open(Door): not locked(Door) @p1
<- turn_handle(Door); push(Door); ?open(Door).”) +open(Door): not locked(Door) <-
turn_handle(Door); push(Door); ?open(Door).

.send(r, untellHow, “@p1”)

S R
Sintaxis en AgentSpeak
● Comunicación entre agentes
○ Ejemplos: askHow

+ Agente s le pide a r que le envie el plan.

.send(r, askHow, “@p2”)
- Si r tiene no tiene planes → envía false.
- Si r tiene planes coincidentes → envía todos los planes

S R

1
Planes Acciones 2 Acciones Planes
.send(r, askHow, ”@p2”) @p2
+!buy(Item) : not ~legal(Item) &
price(Item,P) & bank_balance(B) &
B>P <- pay(P,B); take(Item).
@p2
.send(r, tellHow, ”@p2
+!buy(Item) : not ~legal(Item)
+!buy(Item) : not ~legal(Item) &
& price(Item,P) &
price(Item,P) &
bank_balance(B) & B>P <-
bank_balance(B) & B>P <-
pay(P,B); take(Item).
pay(P,B); take(Item).”)

S R
Sistemas Inteligentes
David Ruano Ordás
Departamento de Informática
[email protected]
Despacho 409