Facultad de Ciencias de la Administración

Carrera: Ingeniería de Sistemas

Tesis de grado.

Título:
“Metodología para el desarrollo de sistemas multi-agente con
ejemplo del desarrollo de una inteligencia artificial para aplicar en
el juego S.P.I.A.-Wari”

Director de tesis: Prof. Ing. Daniela Diaz

Alumno: Daniel Víctor José Antokoletz Huerta

Mesa Examinadora:
Prof. Ing.
Prof. Ing.
Prof. Ing.

Año 2016
 Historia de Revisión del Documento

Fecha Versión Descripción Autor

11/08/2015 1.0.0 Creación Daniel Antokoletz Huerta

Dedicatoria

Dedico éste trabajo a Mónica, mi esposa y

a Erik, mi hijo, que me inspiran a seguir
adelante cuando fallan las fuerzas. Entre
los tres somos un sistema multi-agente en
toda regla.
Agradecimientos
Índice

Historia de Revisión del Documento______________________________________________3

Dedicatoria_________________________________________________________________4
Agradecimientos_____________________________________________________________5
Índice______________________________________________________________________5
Resumen__________________________________________________________________11
Palabras clave______________________________________________________________12
Listado de símbolos y convenciones_____________________________________________13
1. Introducción____________________________________________________________15
1.1. Motivación del proyecto____________________________________________________18
1.2. Alcances del proyecto______________________________________________________19
1.3. Organización del trabajo____________________________________________________20
1.4. Mapa Conceptual__________________________________________________________21
Propósito de la sección____________________________________________________________23
2. De los agentes__________________________________________________________23
2.1. Introducción______________________________________________________________23
2.2. ¿Constituyen los agente un nuevo paradigma de desarrollo de software?____________25
2.2.1. Agentes vs. Objetos_____________________________________________________________26
2.3. Mitos y verdades de la programación con Agentes_______________________________27
3. El concepto de agente____________________________________________________28
3.1. ¿Qué es un agente?________________________________________________________28
Un agente es un sistema de computadora…_______________________________________________29
…Que está situado en un entorno…_____________________________________________________30
…y es capaz de realizar acciones autónomas para conseguir sus objetivos de diseño.______________32
3.2. Arquitectura y modelos de agentes.___________________________________________35
3.2.1. Propósito de la sección__________________________________________________________35
3.2.2. Caracterización de un agente_____________________________________________________35
3.2.3. Arquitecturas de agentes_________________________________________________________36
3.2.4. Arquitecturas reactivas__________________________________________________________38
3.2.4.1. Sistemas de producción_____________________________________________________38
3.2.4.2. Sistemas de subsunción_____________________________________________________41
3.2.4.3. Máquinas de estados_______________________________________________________44
 Máquina de Turin_______________________________________________________________47
Maquina de Mealy______________________________________________________________49
3.2.4.4. Redes___________________________________________________________________50
Modelo no-lineal de una neurona. El perceptrón________________________________________51
Función de activación______________________________________________________________53
Arquitectura de una red neuronal____________________________________________________54
Aprendizaje de las redes neuronales__________________________________________________57
3.2.4.5. Tareas competitivas________________________________________________________62
3.2.5. Arquitecturas basadas en lógica___________________________________________________64
3.2.5.1. Lógica proposicional y de predicados___________________________________________64
3.2.5.2. Lógica modal______________________________________________________________65
3.2.5.3. Lógica deóntica____________________________________________________________66
3.2.5.4. Lógica temporal___________________________________________________________67
3.2.5.5. Lógica Epistémica__________________________________________________________69
3.2.5.6. Lógica Doxástica___________________________________________________________70
3.2.6. Arquitecturas deliberativas_______________________________________________________70
3.2.6.1. Arquitecturas BDI__________________________________________________________71
3.2.6.2. Agentes planificadores______________________________________________________73
3.2.6.3. IRMA____________________________________________________________________75
3.2.6.4. GRATE___________________________________________________________________76
3.2.6.5. PRS_____________________________________________________________________77
3.2.6.6. SOAR____________________________________________________________________78
3.2.7. Arquitecturas mixtas____________________________________________________________80
3.2.7.1. TURINGMACHINES_________________________________________________________81
3.2.7.2. Arquitectura InteRRaP______________________________________________________81
3.2.7.3. Guardian_________________________________________________________________82

4. De cómo los agentes se reúnen y forman sistemas multi-agente__________________84

4.1. Introducción______________________________________________________________84
4.2. Comunicación entre agentes_________________________________________________84
4.2.1. Introducción___________________________________________________________________84
4.2.2. ¿Qué es comunicar?_____________________________________________________________85
4.2.3. Formas de comunicación entre los agentes.__________________________________________85
4.2.3.1. Comunicación mediante el entorno____________________________________________85
4.2.3.2. Comunicación mediante sistema de pizarra_____________________________________86
4.2.3.3. Interacción sin comunicación.________________________________________________87
4.2.3.4. Comunicación a nivel de conocimiento.________________________________________88
 4.2.3.4.1. Tipo de información______________________________________________________88
4.2.3.4.2. Tipo de realización de acciones_____________________________________________88
4.2.3.4.3. Tipo de negociación______________________________________________________89
4.2.3.4.4. Tipo de intermediación___________________________________________________89
4.2.4. Pasaje directo de mensajes.____________________________________________________89
4.2.4.1. Estándares y protocolos de mensajes__________________________________________89
4.2.4.2. FIPA-ACL_________________________________________________________________89
4.2.4.2.1. Operaciones de los mensajes______________________________________________91
4.2.4.2.2. Protocolos definidos según las acciones______________________________________92
4.2.4.2.2.1. Protocolo FIPA-Request___________________________________________________93
4.2.4.2.2.2. Protocolo FIPA-Query____________________________________________________94
4.2.4.2.2.3. Protocolo FIPA-contract-net_______________________________________________94
4.2.4.3. KQML___________________________________________________________________96
4.2.4.3.1. Capas del lenguaje KQML_________________________________________________97
4.2.4.3.2. Sintaxis de KQML________________________________________________________98
4.2.4.3.3. Semántica de KQML_____________________________________________________100
4.3. Coordinación en sistemas multi-agente_______________________________________100
4.3.1. Introducción__________________________________________________________________100
4.3.2. Tipos de relaciones entre los agentes______________________________________________100
4.4. Lenguajes y herramientas de programación de agentes__________________________101
4.4.1. Introducción__________________________________________________________________101
4.4.2. Lenguaje: 2APL/3APL___________________________________________________________101
4.4.2.1. Sintaxis____________________________________________________________________102
4.4.2.2. El ciclo deliberativo__________________________________________________________104
4.4.3. Plataforma: AF-APL____________________________________________________________104
4.4.3.1. Lenguaje de programación____________________________________________________105
4.4.3.2. Entorno de desarrollo________________________________________________________105
4.4.3.3. Entorno de ejecución________________________________________________________105
4.4.3.4. Metodología de ingeniería de software__________________________________________105
4.4.4. Plataforma: AgentBuilder_______________________________________________________106
4.4.5. Lenguaje: AgentK______________________________________________________________107
4.4.6. Plataforma: AgentTool__________________________________________________________107
4.4.7. Lenguaje: April________________________________________________________________107
4.4.8. Lenguaje: CAFnE_______________________________________________________________107
4.4.9. Lenguaje: CLAIM_______________________________________________________________108
4.4.10. Lenguaje: ConGoLog_________________________________________________________108
 4.4.11. Lenguaje: COUGAAR_________________________________________________________108
4.4.12. Infraestructura: CYBELE_______________________________________________________108
4.4.13. Lenguaje: DALI______________________________________________________________109
4.4.14. Plataforma: DESIRE__________________________________________________________109
4.4.15. Lenguaje: FIPA-OS___________________________________________________________109
4.4.16. Lenguaje: FLUX_____________________________________________________________109
4.4.17. Lenguaje: FORR_____________________________________________________________109
4.4.18. Lenguaje: Goal______________________________________________________________110
4.4.19. Lenguaje: GoLog____________________________________________________________110
4.4.20. Lenguaje: IMPACT___________________________________________________________110
4.4.21. Lenguaje: IndiColog__________________________________________________________110
4.4.22. Lenguaje: Jack______________________________________________________________110
4.4.23. Lenguaje: Jade______________________________________________________________110
4.4.24. Plataforma: Jadex___________________________________________________________110
4.4.25. Lenguaje: JAFMAX___________________________________________________________110
4.4.26. Lenguaje: Jason_____________________________________________________________110
4.4.27. Lenguaje: KABUL____________________________________________________________111
4.4.28. Lenguaje: MADKIT___________________________________________________________111
4.4.29. Lenguaje: MDLP_____________________________________________________________111
4.4.30. Lenguaje: METATEM_________________________________________________________111
4.4.31. Lenguaje: MINERVA__________________________________________________________111
4.4.32. Lenguaje: NetLogo___________________________________________________________111
4.4.33. Lenguaje: OAA______________________________________________________________111
4.4.34. Lenguaje: Placa_____________________________________________________________111
4.4.35. Lenguaje: Procedural Reasoning System_________________________________________111
4.4.36. Lenguaje: Pups P3___________________________________________________________112
4.4.37. Lenguaje: RETSINA__________________________________________________________112
4.4.38. Lenguaje: ReSpecT___________________________________________________________112
4.4.39. Lenguaje: SARL_____________________________________________________________112
4.4.40. Lenguaje: SOAR_____________________________________________________________113
4.4.41. Lenguaje: StarLogo__________________________________________________________113
4.4.42. Plataforma: TuCSoN_________________________________________________________113
4.4.43. Lenguaje: Viva______________________________________________________________113

5. Metodologías de desarrollo de sistemas multiagente_________________________116

5.1. Introducción_____________________________________________________________116
5.1.1. Introducción__________________________________________________________________116
 5.2. Marco de análisis de metodologías agentes___________________________________116
5.2.1. Introducción__________________________________________________________________116
5.2.2. Metamodelos_________________________________________________________________116
5.2.3. Marco de análisis______________________________________________________________116
5.3. Metodologías de desarrollo de sistemas multiagentes.__________________________116
5.3.1. Introducción__________________________________________________________________116
5.3.2. Metodología: AAII/BDI__________________________________________________________117
5.3.3. Metodología: AALADIN_________________________________________________________117
5.3.4. Metodología: ANIC_____________________________________________________________117
5.3.5. Metodología: ARCHON__________________________________________________________117
5.3.6. Metodología: Cassiopeia________________________________________________________117
5.3.7. Metodología: CommonKADS_____________________________________________________117
5.3.8. Metodología: CoMoMAS________________________________________________________117
5.3.9. Metodología: DESIRE___________________________________________________________117
5.3.10. Metodología: Gaia___________________________________________________________117
5.3.11. Metodología: INGENIAS______________________________________________________117
5.3.12. Metodología: MADE_________________________________________________________117
5.3.13. Metodología: MASB Method__________________________________________________118
5.3.14. Metodología: MaSE__________________________________________________________118
5.3.15. Metodología: MASSIVE_______________________________________________________118
5.3.16. Metodología: MESSAGE______________________________________________________118
5.3.17. Metodología: ODAC__________________________________________________________118
5.3.18. Metodología: PASSI__________________________________________________________118
5.3.19. Metodología: Prometheus____________________________________________________118
5.3.20. Metodología: RETSINA_______________________________________________________118
5.3.21. Metodología: TROPOS________________________________________________________118
5.3.22. Metodología: Vowels engineering______________________________________________118
5.3.23. Metodología: ZEUS__________________________________________________________119
5.4. Marco de comparación de Metodologías______________________________________119
6. Metodología GAIA de desarrollo de sistemas multiagentes.____________________122
6.1. Introducción_____________________________________________________________122
6.1.1. Propósito de la sección_________________________________________________________122
6.1.2. Alcances de la sección__________________________________________________________122

7. Implementación_______________________________________________________123
7.1. Introducción_____________________________________________________________123
7.1.1. Propósito de la sección_________________________________________________________123
 7.1.2. Alcance de la sección___________________________________________________________123
7.2. Desarrollo de la IA para el juego SPIA-Wari____________________________________123
7.2.1. Introducción__________________________________________________________________123

8. Conclusiones__________________________________________________________123
Referencias/Bibliografía_____________________________________________________125
9. Anexos_______________________________________________________________128
9.1. Códigos de transmisión.___________________________________________________128
9.2. Reglas del juego WARI.____________________________________________________130
9.2.1. Material_____________________________________________________________________130
9.2.2. Objetivo_____________________________________________________________________131
9.2.3. Reglas_______________________________________________________________________131
9.2.4. Tablero______________________________________________________________________131
9.2.5. Movimiento__________________________________________________________________131
9.2.6. Capturas_____________________________________________________________________132
9.2.7. Reglas Suplementarias__________________________________________________________133
9.2.8. Fin de la Partida_______________________________________________________________134
9.2.9. Breves notas sobre técnica y estrategia____________________________________________135
 Resumen

La idea del proyecto es, en primer lugar dar una introducción teórica de los sistemas
multi-agente, a continuación se analizarán las diferentes metodologías de desarrollo
de sistemas multi-agente. Siguiendo una de ellas, se diseñará una aplicación de
inteligencia artificial para el sistema SPIA-Wari (desarrollado como trabajo práctico
final de pregrado). Luego, el presente proyecto es una consecuencia de los
problemas hallados para el desarrollo del proyecto de pregrado desarrollado en el
año 2014.
 Palabras clave

Laboratorio de inteligencia artificial

IA
Inteligencia Artificial
Desarrollo de una inteligencia artificial
Sistemas multi-agentes
Metodología de desarrollo de sistemas Multi-agentes
 Listado de símbolos y convenciones

En el presente documento utilizaremos las siguientes definiciones, acrónimos y

abreviaturas.

IA Inteligencia Artificial

S.P.I.A. Sistema de Prueba de Inteligencia Artificial.

GNU GNU es un acrónimo recursivo que significa GNU No es Unix (GNU is

Not Unix). El proyecto GNU fue iniciado por Richard Stallman con el
objetivo de crear un sistema operativo completamente libre: el sistema
GNU. http://www.gnu.org

GPL La GNU GPL (General Public License o licencia pública general) es una
licencia creada por la Free Software Foundation a mediados de los 80,
y está orientada principalmente a proteger la libre distribución,
modificación y uso de software. Su propósito es declarar que el
software cubierto por esta licencia es software libre y protegerlo de
intentos de apropiación que restrinjan esas libertades a los usuarios.
http://www.gnu.org/copyleft/gpl.html
http://www.garaitia.com/new/gpl-spanish.php

Software Software libre (en inglés free software) es el software que, una vez
Libre obtenido, puede ser usado, copiado, estudiado, modificado y
redistribuido libremente. El software libre suele estar disponible
gratuitamente, pero no hay que asociar software libre a software
gratuito, aunque conserve su carácter de libre, puede ser vendido.
http://www.fsfla.org/

Posix POSIX corresponde a las iniciales de interfase de sistema operativo

portable
(Portable Operating System Interface). Es un estándar de interfase de
sistema operativo, basado en el popular sistema operativo UNIX. El
estándar POSIX está actualmente en desarrollo, y su principal objetivo
es permitir la portabilidad de aplicaciones a nivel de código fuente, es
decir, que sea posible portar una aplicación de un computador a otro sin
más que recompilar su código. Está siendo desarrollado por la
Computer Society de IEEE, con la referencia IEEE-P1003. También
está siendo estandarizado a nivel internacional con la referencia
ISO/IEC-9945.
SMA Sistema Multi-Agente

RNA Red neuronal artificial

Semilla Es la ficha de juego

Agujero Posición del tablero. Son las casillas en dónde se desarrolla el juego.

Almacén Posiciones extremas del tablero que almacenan las fichas ganadas por
cada uno de los jugadores
 1. Introducción

Según menciona Michael Wooldridge en "An introduction to multi-agent systems" [1] si

analizamos la historia y la actualidad de la computación está marcada por cinco
tendencias:

 Ubicuidad: Es indudable la continua reducción de costos y el aumento de la

capacidad computacional de los equipos según la ley de Moore. La ley de
Moore expresa que, aproximadamente cada dos años, se duplica el número
de transistores en un circuito integrado. Las computadoras son cada vez más
pequeñas y considerablemente más poderosas. Hoy en día el celular más
pequeño tiene más memoria y capacidad de procesamiento que el AGC
(Apollo Guidance Computer) que permitió la llegada del hombre a la luna.

 Interconexión: en la historia de la computación, los grandes computadores

se encontraban totalmente aislados. Su única comunicación con el mundo
exterior era a través de los operadores. Hoy, hablar de una computadora
aislada, o de un dispositivo incomunicado, sería impensable. La presencia de
las redes, especialmente de Internet, irrumpió en nuestras vidas y casi todos
los dispositivos electrónicos se interconectan entre sí a través de Internet
formando enormes sistemas distribuidos.

 Inteligencia: Los sistemas son cada vez más complejos y, muchas veces,
esa complejidad se traduce en un comportamiento cada vez más inteligente.
Si bien, hablar de inteligencia podría requerir de libros enteros, hay que
admitir que muchos elementos actuando de cierta manera, podría constituir
un comportamiento inteligente.
Por ejemplo, una hormiga sola, no es un organismo inteligente, pero un
hormiguero, ¿no tiene una sociedad organizada?
Para tener una sociedad organizada, se requiere de un tipo de inteligencia.
Luego, tienen hormigas guerrero, trabajadoras comunes, reproductoras,
agricultoras y, por supuesto, la reina. Por separado, las hormigas funcionan
de manera elemental, pero juntas, presentan una inteligencia distribuida.

 Delegación: esta tendencia es una consecuencia lógica de la aplicación de

las tecnologías a la realidad, del abaratamiento y crecimiento de la potencia
computacional. Si prestamos atención a nuestras vidas, cada vez más,
delegamos las decisiones y las operaciones que realizamos diariamente en
las computadoras. Es fácil ver cómo se delega en sistemas robóticos la
construcción de vehículos, el control de los sistemas de vuelo de los aviones
 y sondas espaciales, la programación de nuestros viajes, los sistemas de
tránsito, etc.

 Orientación humana: La tendencia actual, es un movimiento alejándose de

las vistas orientadas a las máquinas, hacia conceptos y metáforas más
acordes a la manera de pensar de los seres humanos.
Si prestamos atención nuevamente a la historia de la computación, tiene
sentido porque, en los inicios de la computación, los primeros programas los
hacían gurúes manipulando clavijas e interruptores. Luego se pasó a tarjetas
preforadas y programas lineares escritos en Assembler. Aparecieron los
primeros lenguajes orientados a procedimientos como el Fortran y el Cobol.
A continuación, aparecieron las consolas de texto y se consolidaron los
lenguajes de programación orientados a procedimientos, aparecieron los
primeros lenguajes sencillos como el Basic. También emergieron las
consolas gráficas y con ellas la programación orientada a eventos, entonces
la ejecución de los programas ya no era lineal. Comienzan las mejoras para
la programación, aparecen los primeros IDEs (Integrated development
environment – Entorno de desarrollo integrado) con impresionantes ayudas
al momento de programar. Se sube un nivel de abstracción y aparece la
programación orientada a objetos.
En la actualidad hay entornos de desarrollo que permiten programar
utilizando bloques sin que el programador deba tener grandes conocimientos
de programación (Scratch y AppInventor de Android).

Paradigma de programación orientada a agentes

Paradigma de programación orientada a objetos

Abstracción de tipos de datos

Paradigma procedural

(Paradigma lineal)
Assembler
o
deMáquina
Código

Cód máqu

Ilustración 1:Paradigmas de programación

Se puede observar que, desde la programación en código de máquina a la
programación orientada a objetos, los lenguajes se van acercando a la manera de
pensar se los seres humano. En los primeros tiempos, los primeros programadores
eran considerados gurús, y la programación era oscura y elitista.
En la actualidad, puede programar toda persona que posea un mínimo de
conocimiento. Y este camino lleva (entre otras bifurcaciones) a la programación
orientada a agentes.
Como se podrá comprobar, en la primera parte de éste trabajo, los seres humanos
piensan y se comportan como agentes.

La programación orientada a agentes aparece como consecuencia de las tendencias

mencionadas. Y surge el interrogante, ¿es la única posibilidad? No. Sin dudas no. La
programación orientada a agentes permite acercarse más a la forma de pensar del
ser humano.
En la actualidad, son pocos los sistemas multi-agente completamente operativos,
las tecnologías basadas en agentes se encuentran en desarrollo. Dichas tecnologías
son aún inmaduras. De todas formas, la robustez y tolerancia a fallos que promete,
hacen que sea ideal para sistemas aero-espaciales, control de tráfico aéreo,
medicina, control de procesos electrónicos, automotrices, logística, minería de datos,
etc.
 1.1. Motivación del proyecto

En mi proyecto de pregrado, he desarrollado un juego como laboratorio de

inteligencia artificial. El mismo, permite que se desarrollen módulos de inteligencia
artificial para que compitan entre sí. Si bien en su momento y para poder probar el
juego, desarrollé un par de módulos de IA para poder demostrar la funcionalidad del
juego, las mismas estaban desarrolladas exclusivamente utilizando tecnologías de
subsunción.
Cuando desarrollé ese proyecto, me he encontrado con problemas en la aplicación
de metodológia de desarrollo de software. Intenté aplicar RUP (Rational Unified
Process), y se complicó en varios aspectos no siendo totalmente adecuado para el
tipo de desarrollo del que se trataba.
En este trabajo, originalmente, me proponía desarrollar un módulo de IA para poder
aplicarla al juego S.P.I.A. Wari utilizando varias técnicas de inteligencia artificial.
Básicamente, quería desarrollar un sistema multi-agente para la manipulación de los
datos de entrada y la obtención de un número que permita ejecutar una jugada
dentro del S.P.I.A. Wari. Cuando buscaba una metodología para poder hacer el
desarrollo, me encontré con que ninguna era completa y que, para poder realizar
concienzudamente ese trabajo, primero debería analizar las metodologías.
Lógicamente, para poder analizar las metodologías primero hay que tener en claro
los conceptos.
El proyecto terminó siendo el desarrollo de la metodología, y el diseño del módulo de
inteligencia artificial quedó como ejemplo de aplicación del mismo.
 1.2. Alcances del proyecto

El alcance total del proyecto es la aplicación de una metodología de desarrollo de un

sistema multi-agentes, y, como ejemplo, el diseño de una inteligencia artificial que se
pueda se programada y probada en el juego S.P.I.A. Wari, utilizando diferentes
técnicas de inteligencia artificial.
A los fines prácticos, se hará una introducción teórica para unificar los criterios sobre
los conceptos a aplicarse tanto de agentes tratados de manera unitaria como unidos
en sistemas multi-agente, se definirá la metodología de desarrollo y, como último
punto, se seguirá paso a paso esa metodología para el desarrollo de la IA. Se
intentará responder las preguntas,
¿Qué es necesario para desarrollar…?
¿Qué es necesario para desarrollar un agente?
¿Qué es necesario desarrollar para que los agentes se comuniquen?
¿Qué se necesita para desarrollar un sistema multi-agente?
Para obtener respuestas a las preguntas precedentes, es necesario encontrar la
información sobre los temas que debería tener en cuenta una metodología para que
se pueda desarrollar, de manera racional y ordenada, un sistema multi-agente
funcional.
 1.3. Organización del trabajo

Este trabajo está desarrollado en tres partes y algunos anexos:

PARTE I: Marco Teórico: Agentes y programación orientada a agentes.

En ésta parte se expondrán los conceptos de agentes, los tipos de agentes,

inteligencia de los agentes. Los sistemas multi-agentes, los tipos de sistemas multi-
agente, modos de comunicación entre agentes y lenguaje de comunicación entre
agentes,

PARTE II: Metodología de desarrollo de los sistemas multi-agentes

Las metodologías de desarrollo convencionales pueden ser inadecuadas para el

desarrollo de sistemas multi-agentes. Se analizarán las diferentes metodologías
existentes en la actualidad verificando sus bondades y sus falencias. Se intentará
definir una metodología extendiendo una de las existentes a fin de tratar de
subsanar sus falencias.

PARTE III: Aplicación de una metodología

Se tomará el diseño de un módulo de inteligencia artificial para ser aplicado al juego

S.P.I.A. Wari, siguiendo la metodología desarrollada en la parte anterior a fin de
tener un ejemplo práctico de la misma.

ANEXOS:
Al final del trabajo, se presentarán anexos con el reglamento del juego SPIA Wari,
las características que deben tener las IA para el juego, la codificación para la
comunicación, la licencia GNU y, al final, desarrollos introductorios de las teorías
involucradas que se utilizan en la programación de los agentes.
1.4. Mapa Conceptual
PARTE I
Marco teórico: De los
agentes y cómo se
reúnen en sistemas multi-
agentes.
Propósito de la sección

El propósito de la esta sección, es presentar una introducción teórica de los sistemas

multi-agente.
Se Pasará del análisis de un solo agente viendo sus características y luego veremos
de la necesidad de aprovechar las características de cada agente para hacerlos
trabajar juntos y/o competir en busca de un objetivo común.
Como se mencionó en el inicio del trabajo, la pregunta que intentaremos responder
en ésta sección, es ¿Qué es necesario conocer para desarrollar un agente?

2. De los agentes
2.1. Introducción

Películas como Terminator con una inteligencias distribuida como Skynet se trata de
un posible escenario no muy lejano. De hecho, en la actualidad, aviones no
tripulados como los MQ-1 Predators norteamericanos, pueden llevar misiles
AGM114 Hellfire y tienen cierta autonomía operativa. El MQ-9 Reaper puede llevar
armamento hasta 4500 Kg.

Ilustración 1:Predator

Es cuestión de tiempo que, por razones operativas, se vaya aumentando esa

autonomía de operación…

En Rusia, las plataformas robóticas "Soldado universal", fueron diseñadas para

combate autónomo. Un ejemplo de éste tipo de plataforma es el Complejo robótico
móvil Volk-2 como el que se ve en la imagen.
 Ilustración 1: Volk-2

Sin importar su tamaño y complejidad, las computadoras necesitan de un conjunto

de instrucciones ordenadas para poder funcionar y lograr sus objetivos (¿No es
posible pensar que los humanos también tenemos instrucciones?). Sin éstas
instrucciones, son un conjunto de componentes electrónicos sin más utilidad que un
pisapapeles caro. Esas instrucciones son dadas por programadores "todavía"
humanos. Incluso esos programitas que todo el mundo conoce: se copian y activan
en nuestros equipos, y se contagian a otros ordenadores y celulares para obtener
control sobre ellos. Son los troyanos y los virus.

Como hemos visto en la introducción de éste trabajo, una de las tendencias es dotar
a los sistemas de más y más "inteligencia" y "autonomía". Hasta hace poco tiempo,
los programas tenían que ser guiados por un operador, pero en ciertas operaciones
el esperar por la acción de un humano, puede hacer peligrar los objetivos del
sistema entonces, se opta por darle más autonomía.
Veamos los siguientes escenarios:
 Operaciones de trading: en el mundo de los negocios de bolsa, las
operaciones son cada vez más rápidas. Hay sistemas que se encargan de
monitorear segundo a segundo el valor de las acciones. Muchas veces, el
operador tiene que estar siguiendo decenas o centenas de acciones para
poder actuar y debe comprar y vender las mismas en cuestión de minutos
para obtener ganancias significativas. Es imposible, físicamente, semejante
atención en un humano. Para poder automatizar esas operaciones se opera
con agentes software con algoritmos que reconocen ciertos patrones o que se
activan cuando se dan ciertas características en los valores de las acciones y
que tienen posibilidad de comprar o vender.
 Operaciones espaciales: El envío de robots a explorar diferentes planetas,
asteroides y cometas son cada vez más frecuentes. Una sonda planetaria
como el Oportunity de la NASA que se encuentra explorando el planeta Marte
desde 2004, tiene un comportamiento autónomo que le permite tomar ciertas
decisiones sin necesidad que control de misión la corrobore.
 Ilustración 1: Oportunity
Hay que tener en cuenta que, en el mejor de los casos, el tiempo que requiere
la información de los sensores desde Marte hasta La Tierra y la vuelta con las
instrucciones (suponiendo que el operador de misión responda
inmediatamente), lleva varios minutos ya que la velocidad de las
comunicaciones no es infinita, no son instantáneas, no pueden superar la
velocidad de la luz. Incluso hay que tener en cuenta que en muchos casos la
comunicación se torna imposible ya que La Tierra y Marte se encuentran en
los puntos opuestos de las órbitas con el Sol en el medio.
 Operaciones de vuelo en aeronáutica: Los sistemas electrónicos de un avión,
en especial en un avión de combate, cumplen con sus objetivos de manera
autónoma para quitarle ciertas responsabilidades a los pilotos como mantener
la estabilidad y el sistema de puntería,
 Operaciones en una central nuclear: No requiere de mucha explicación el
darle autonomía a los sistemas de seguridad de una central nuclear.

Al darle más autonomía e inteligencia a programas podemos decir que nos

encontramos frente a agentes software.
Por supuesto que no es necesario llegar a casos extremos para utilizar agentes. En
muchas operaciones diarias, también se utilizan agentes: en juegos, en medicina, en
plantas fabriles, en reservas de pasajes, en operaciones de comercio, etc.

2.2. ¿Constituyen los agente un nuevo paradigma de desarrollo

de software?

En primer lugar, se puede decir que un paradigma de programación, podría definirse

como una tecnología de desarrollo que es adoptada por la comunidad de
programadores. Una de las características principales es que un paradigma tiene un
dominio específico de problemas a resolver claramente definidos.
Si observamos la historia de la programación, podemos ver los siguientes
paradigmas:

 Paradigma imperativo (procedimientos)

 Paradigma funcional (declarativo)
 Paradigma lógico (declarativo)
 Paradigma orientado a objetos
 Paradigma de programación dinámica

En la actualidad, la mayoría de los programadores se alinean con la programación

orientada a objetos en primer lugar y con el imperativo en segundo lugar. En ambos
casos suele mezclarse con la programación dinámica (se divide el problema en
problemas menores de más fácil solución).

Teniendo en cuenta las tendencias enunciadas al comienzo del trabajo, se observa

que la programación orientada a agentes es, probablemente, un nuevo paradigma
de desarrollo. Aún se encuentra en los estados iniciales, pero es claro que está
evolucionando a pasos agigantados.

Lo extraño de éste paradigma es que la manera en que se está desarrollando sirve

no sólo para el desarrollo de agentes software, sino también para el análisis y
simulación de cualquier tipo de situación en dónde se involucran individuos o
comunidades (seres humanos o ecosistemas). Todas las definiciones que se
detallan sobre agentes y multi-agentes, pueden aplicarse tranquilamente a las
personas o a cualquier tipo de ecosistema. En el artículo "Intervening to archieve
co-operative ecosystem management: Towards an agent based model" [2] Doran
propone un modelo basado en agentes para simular la gestión de ecosistemas.

2.2.1. Agentes vs. Objetos

Cuando recién se comienza a desarrollar con agentes y ya se ha trabajado con
programación orientada a objetos, el programador tiene tendencia a pensar que no
hay diferencia entre ambas tecnologías. Nada más alejado de la realidad. Las
diferencias son no sólo conceptuales, sino también prácticas.

Para poder ver la diferencia entre ambas tecnologías, Wooldridge enunció muy
claramente las diferencias entre agentes y objetos [1]. Veamos la siguiente lista:
 Los agentes tienen autonomía, los objetos no. Veremos más adelante en la
definición de agente que un agente recibe un estímulo y realiza una acción.
Es él mismo quien decide cuándo aceptar el estímulo y cómo reaccionar ante
 él. Los objetos, al igual que los agentes, se comunican utilizando mensajes,
que no son otra cosa que métodos públicos que se activan para realizar sus
operaciones. Pero los objetos no tienen control sobre el momento en que se
activan sus métodos. El control lo tiene el objeto que lo llama. En cambio, el
agente tiene el control sobre sí mismo.
 Los agentes, por definición, reaccionan al entorno y lo modifican. Los objetos,
por otro lado, modifican su estado interno y es el objeto llamante quien le
entrega los datos y le pide los resultados. Es cierto que los agentes también
modifican su estado interno, pero lo realizan en función de su interacción con
el medio.
 Los agentes están pensados para ejecución distribuida y, se tiene muy en
cuenta el concepto de paralelismo. Cada agente tiene sus propios recursos.
Según Wooldridge los agentes deben que tener, necesariamente, al menos
un hilo de ejecución (como un proceso de Unix). Los objetos pueden
ejecutarse en diferentes hilos, pero no es una condición necesaria.
 Los agentes manifiestan un comportamiento flexible, reactivo y, muchas
veces, proactivo. También puede observarse que tienen un comportamiento
social, ya sea colaborativo o competitivo. Son reactivos, porque perciben el
entorno. Los objetos sólo se ejecutan a demanda. Cuando se le presenta al
agente una situación no totalmente contemplada entre sus reglas de
operación, tiene la flexibilidad necesaria para adaptarse y tratar de cumplir
con sus objetivos incluso en ese entorno. Es proactivo porque no sólo intenta
cumplir con sus objetivos, sino que también los genera. Muchas veces toma
la iniciativa.
Lo dicho anteriormente, no significa que no se pueda utilizar la tecnología de
programación orientada a objetos para programar los agentes, sino que están en
distintos niveles de abstracción.

2.3. Mitos y verdades de la programación con Agentes

Cuando se menciona sistema multi-agentes, la gente común e incluso los
programadores que no tuvieron acceso a éste tipo de tecnología, tiene ciertas
creencias. Supongo que, con la siguiente lista, aclararemos muchos puntos:
 Los agentes pueden aprender y hacer cualquier cosa: Los agentes no son
magia. Pueden hacer lo que se le imponga por diseño, nada más.
 Hay cosas que sólo pueden hacerse con agentes: Si hay algo que no se
puede hacer con programación estándar, sin duda, tampoco podrá realizarse
utilizando tecnología de agentes. Hay ciertas cosas que los agentes pueden
hacer de manera más sencilla. No pueden hacer posible lo imposible.
 Los agentes son el santo grial del desarrollo de software: Nada más lejos de
la realidad. No son omnipotentes. Como toda herramienta, es la ideal para
cierto tipo de problemas (en especial los que se ejecutan de manera
 distribuida). Para otro tipo de desarrollos, es mejor el paradigma de objetos y,
para otro, el viejo paradigma procedural.
 Mejor si se puede desarrollar usando MAS: Dada la complejidad de un
desarrollo de un sistema multi-agentes (lo veremos en el desarrollo de éste
trabajo), si para una solución se pueden aplicar tanto tecnología MAS como
POO o cualquier otra, hay que optar siempre por la que sea más sencilla.
 Para mi proyecto debo desarrollar mi propia arquitectura: Durante el
transcurso de los años, se desarrollaron muchas arquitecturas de agente. Sin
duda hay alguna que se amolde al proyecto. Desarrollar una arquitectura
como corresponde, puede llevar mucho tiempo (años).

3. El concepto de agente
3.1. ¿Qué es un agente?

Como todo concepto de éste tipo, que es un concepto aprovechado desde otro
dominio, tiene una definición un tanto controversial.
¿Por dónde empezar?
Empezamos por la definición que da la Real Academia Española y la etimología de
la palabra:

"Agente: (del latín agens - entis, part, act de agere, hacer)

1-Que obra o tiene virtud de obrar.
…
2-Persona o cosa que produce un efecto.
…
"

Verificando en la wikipedia, podemos ir especificando más la definición:

"Un agente inteligente es una entidad capaz de percibir su entorno, procesar tales
percepciones y responder o actuar en su entorno de manera racional, es decir, de
manera correcta y tendiendo a maximizar un resultado esperado. Es capaz de
percibir su medio ambiente con la ayuda de sensores y actuar en ese medio
utilizando actuadores (elementos que reaccionan a un estímulo realizando una
acción)"
 Ilustración 1:Agentes-Entorno

Por las definiciones que se plasmaron hasta ahora, podemos ver que es aplicable a
un agente humano, biológico, químico, etc. En cualquiera de ellos se aplica el
concepto a la perfección.

En éste trabajo nos abocaremos al estudio de los agentes informáticos, más

específicamente de los agentes software.
Wooldridge, ha dado una de las definiciones más citadas en la bibliografía, y la que
desmenuzaremos:

"Un agente es un sistema informático situado en un entorno y que es capaz de

realizar acciones de forma autónoma, para conseguir sus objetivos de diseño" [3].

Un agente no es, necesariamente, un robot, pero un robot, que sin duda es un

agente, nos permite hacernos una idea de lo que es un agente.
Un robot se mueve dentro de un entorno específico. Si se diseña una sonda
espacial, tendrá su utilidad en el espacio. Sus sensores y efectores o actuadores,
interpretarán y operarán correctamente si están en el entorno apropiado.
El robot tiene sensores a través de los cuales puede percibir su entorno. Puede
tratarse de bigotes si tiene que moverse evitando impactar superficies, ultrasonido si
tiene que medir distancias, sensores de presión, si tiene que levantar objetos o
visión si debe cumplir con objetivos observacionales.
Hasta aquí el robot percibe el mundo y, cuanto mucho, realiza un mapeo de ese
entorno en su interior. De manera que, si necesitamos y deseamos (lógicamente
para eso lo desarrollamos) que modifique su entorno (haga algo), se le agregan
actuadores apropiados a la tarea a realizar. Los efectores son las herramientas que
tiene el robot/agente para actuar sobre el medio. Puede tratarse de ruedas o patas
para moverse, brazo mecánico para realizar ciertas operaciones, parlantes para
emitir sonidos o pantallas para mostrar información.

Analizaremos a continuación, la definición de Wooldridge que, a mi manera de ver,

es una de las más amplias y, a la vez, concisas.
Un agente es un sistema de computadora…

Como hemos mencionado, en éste trabajo nos abocaremos al análisis y diseño de

sistemas con agentes software.
Es cierto que el término agente, como hemos visto, se puede aplicar a gran cantidad
de elementos, incluyendo comunidades hombre/máquina.
Como puede leerse en el artículo "Una Aplicación de la Tecnología de MultiAgentes
a los Sistemas Tutores Inteligentes: Enseñanza de Computación en Carreras de
Ingeniería" [4]. Puede plantearse un sistema multi-agente en la enseñanza en dónde
se combinan agentes software con agentes humanos (alumnos).

…Que está situado en un entorno…

Lógicamente, necesitamos comprender es qué es el entorno.
Lo primero que podemos decir es que el entorno es todo aquello que se encuentra
alrededor del agente y con lo que el agente interactuar, ya sea recibiendo
información desde el mismo o modificándolo.
La RAE define: "entorno (De en- y torno)
1.m Ambiente, lo que rodea
2.m Inform. Conjunto de condiciones extrínsecas que necesita un sistema
informático para funcionar.
…"
Nos quedamos con la segunda
definición, pero veamos un ejemplo:

Tenemos un sistema de refrigeración de

un reactor.
(Imagen: Reed Research Reactor,
Creative Commons)
El sistema de refrigeración está inmerso
en agua. Ese agua, rodea a nuestro
sistema que se conecta de una serie de
sensores de temperatura. Cuando la
temperatura pasa de cierto límite,
enciende unas bombas que enfrian a un
radiador por el que se hace circular el
agua para enfriarla. Al otro lado del
radiador, se encuentran las varillas que,
al enfriarse, calientan el agua.

Ilustración 1: Varillas en un reactor

nuclear
Nuestro sistema se compone entonces por los sensores (por donde se reciben las
entradas) y el radiador (el actuador que modifica el entorno). Entonces ¿Cuál es el
entorno? Sin lugar a dudas, el líquido que envuelve a los sensores no forma parte
del sistema, forma parte del entorno.
Las preguntas claves a hacerse es: ¿las varillas forman parte del entorno?¿El
contenedor forma parte del entorno?
Para poder responder esas preguntas, tenemos que fijarnos si esos elementos
interactúan directamente con nuestro agente. Las varillas no interactúan con el
agente-sistema, sino a través del líquido. De manera que podríamos decir que las
varillas no forman parte del entorno. De la misma manera, el contenedor, tampoco
formaría parte del entorno.
Según Wooldridge los entornos se clasifican según varios parámetros:
Según su accesibilidad puede ser:
 Accesible: en éstos entornos, los agentes obtienen información completa,
correcta y en tiempo real del estado del entorno. Cuando el entorno depende
casi exclusivamente de leyes físicas, podemos decir que estamos en éste tipo
de entornos.
 Inaccesible: hay información incompleta sobre el estado del entorno. En la
mayoría de los escenarios reales, no se tiene acceso a toda la información del
entorno.
Lógicamente, cuanto más información se tiene del entorno, mejores decisiones
tomará el agente, cuánto más accesible es el entorno es lo ideal.
Según su certidumbre se clasifica en:
 Determinístico: los entornos determinísticos son aquellos que establece una
relación causa-efecto unívoca. Obviamente, en éstos casos, se descartaría
totalmente la presencia de eventos aleatorios.
 No-Determinístico: en el mundo real, la mayoría de los entornos, pertenecen a
ésta clasificación. Casi siempre hay elementos de incertidumbre en los
entornos reales. Lo importante es tratar de acotar esa incertidumbre y saber
manejarla. Desarrollar agentes para un entorno determinístico no tiene mucho
sentido. Para ello puede desarrollarse un programa común y corriente.
Según su posibilidad de cambio:
 Estático: un entorno es estático cuando permanece inalterable durante todo el
tiempo que necesita el agente para tomar sus decisiones. Las únicas
modificaciones que sufre el entorno es a causa del agente (o de los agentes
cuando se trata de un sistema multi-agente.
 Dinámico: el entorno evoluciona constantemente y el agente debe adaptarse
a ese cambio y anticiparlo. Supongamos el escenario que presenta para un
agente el tener que moverse u operar dentro de internet. El entorno se
encuentra cambiando a cada momento.
Según su continuidad puede ser:
  Discreto: cuando trabajamos en un entorno discreto, estamos en presencia de
un número finito de estados de entorno que puede ser percibido casi
completamente por el agente.
 Contínuo: en éste caso el número de estados que presenta el entorno en
infinito. O, al menos incontable o con demasiadas posibilidades para tenerlas
en cuenta a todas. Para trabajar en éstos entornos, el agente debe clasificar y
agrupar los estados del entorno y, en caso de que se trate de un entorno
analógico, debe digitalizarlo para poder comprenderlo.
El agente necesita disminuir la complejidad tratando de discretizar, hacer más
estático y moverse en un entorno lo más determinístico posible. La realida es
demasiado compleja y las técnicas que se usan en la programación de los agentes
deben, sobre todo disminuir la complejidad.

…y es capaz de realizar acciones autónomas para conseguir sus objetivos de

diseño.
Diseñar un agente que no realice ninguna acción, que no modifique, de alguna
manera, su entorno, no tiene ningún sentido.
Las acciones que puede realizar un agente son de muy variada índole:

 Recopilación de información
 ordenamiento de información
 almacenamiento de información
 coordinación de otros agentes
 realización de tareas físicas
 creación de otro agentes
 transportar objetos (físicos, lógicos,
Ilustración 1: Robot de SUMO
otros agentes)
(Parallax)
 etc.
Sin duda, el límite es la imaginación del diseñador.
Una de las condiciones que establece la definición que estamos analizando es que
realice las operaciones en forma autónoma. En éste momento necesitamos
comprender la diferencia entre un sistema autónomo y un sistema automático.
Para plantear la distinción entre los sistemas automáticos y autónomos, primero
veremos que dice el diccionario de la Real Academia Española sobre las palabras
automático y autónomo:
Para automático la RAE dice lo siguiente:
adj. Perteneciente o relativo al autómata.
 adj. Dicho de un mecanismo: Que funciona en todo o en parte por sí solo.  U. t.
c. s.
adj. Que sigue a determinadas circunstancias de un modo inmediato y la
mayoría de las veces indefectible.
Para autónomo, la RAE define:
Que tiene autonomía.
Que trabaja por cuenta propia. U. t. c. s.

Entonces podemos decir que un Sistema Automático es un sistema que tiene una
serie de pasos prefijados que cumplirá indefectiblemente desde el principio hasta el
final. El salteo de algunos pasos dependerá de la programación, pero jamás será
decisión del propio sistema. Por otro lado, un Sistema Autónomo es aquel que no
necesita de la supervisión de un operario. Tomará decisiones de acuerdo a las
condiciones del entorno y almacenará su experiencia en su memoria interna. El
sistema autónomo es un superconjunto de un sistema automático. Si a un sistema
automático se le adiciona algún tipo de inteligencia que le permita almacenar
experiencia y tomar decisiones no pre-programadas se convertirá en un sistema
autónomo.

Son ejemplos de sistemas automáticos:

 Lavarropas y lavavajillas automáticos (el aparato cargará el agua, moverá la
ropa cierto tiempo, calentará el agua, enjuagará cierta cantidad de veces y
centrifugará cierto tiempo de acuerdo a programas preestablecidos),
 Armas automáticas (el ciclo completo de cargar, amartillar, disparar y extraer
es completamente mecánico)
 Cajero automático (Realiza una gran cantidad de operaciones emulando a un
cajero, pero no poseen inteligencia propia. Realizan siempre los mismos
pasos dependiendo de la operación elegida)
 Robot soldador en una línea de montaje, realiza operaciones de soldadura
sobre piezas de acuerdo a un programa minuciosamente preestablecido. De
hecho, si la pieza que toma se encuentra en mala posición no opera
correctamente y hasta puede detenerse por no poder continuar con el
programa.

Son ejemplos de sistemas autónomos:

 Las sondas robóticas enviadas por la NASA al espacio y a los distintos
planetas para obtener muestras de diferentes planetas, satélites, cometas,
polvo estelar; datos y fotografías.
 Algunos web-bots multiagentes que se utilizan para hacer datamining en
Internet.
  Algunos sistemas expertos que sirven para apoyo de decisiones.
 Algunas secretarias electrónicas que pueden ocuparse de coordinar vuelos y
transportes.

Lo importante que debe tenerse en cuenta es la última parte de la definición es que

las tareas deben tener un objetivo, y ese objetivo, se establece en el momento de
diseño. ¿puede modificarse el objetivo? Creo que la respuesta depende de la
inteligencia del agente. Un humano tomado como un agente, por ejemplo, podría
modificar sus objetivos. Coincidamos que, según las definiciones, un humano entra
dentro de la definición genérica de agente. No es un agente software, pero es un
agente al fin. También tiene sus objetivos, que han sido implantados en el momento
de diseño: alimentarse, sobrevivir y procrear para que la especie se preserve. Pero
pueden ser modificados por la cultura. Así es como podemos ver personas que se
sacrifican por otros: actos de heroísmo donde una persona puede elegir entre su
supervivencia o la supervivencia de los demás. ¿No estará en ese caso también
respondiendo a su programación? En éste caso está primando una de las reglas
implantadas: la supervivencia de la "especie".
 3.2. Arquitectura y modelos de agentes.

Como primer paso se analizará el comportamiento de un agente como ente solitario.

Se considera en todos los casos, que el agente en estudio se comporta siguiendo el
principio de racionalidad. Es decir, la racionalidad significa que no hay azar en el
comportamiento del agente. Esto no quiere decir que deba trabajar con lógica
determinística. Muchos agentes aplican lógica difusa y, otros, lógica modal. Sea
cual sea la arquitectura de agente que se seleccione, la misma determinará el
comportamiento y las decisiones de dicho agente.

3.2.1. Propósito de la sección

En ésta sección se intentará comprender las arquitecturas que, hasta el momento,

se encuentran en los agentes.
Inicialmente se estudiará una caracterización de los agentes, y luego se clasificarán
los agentes de acuerdo a la tecnología que utilizan.
Intentaremos responder: ¿Qué se necesita para desarrollar un agente?

3.2.2. Caracterización de un agente

La arquitectura de un agente, es un mapa de la estructura interna del agente.

Según lo que analizan Corchado, Molina y Pavón [5] los agentes se consideran
sistemas intencionales. Considerarlos de ésta manera nos permite definir
correctamente al sistema mediante sus acciones intencionales. Con intencionalidad
se desea establecer que su comportamiento puede ser totalmente predicho
atribuyéndole creencias, deseos y conducta racional. Pueden ser intencionales de
primer orden (tienen creencias y deseos pero no llegan a tener creencias y deseos
sobre sus creencias y deseos) o intencionales de segundo orden (tienen creencias y
deseos, y creencias y deseos sobre sus creencias y deseos) Según los autores, un
agente contiene actitudes y pro-actitudes.
Las actitudes, que se conocen como actitudes de información, son la representación
interna que el agente hace del entorno. Se encuentran más del lado de los sensores.
Las pro-actitudes, por otra parte, están del lado de los efectores, y están
relacionadas con las acciones que toma el agente. Como se ha dicho en puntos
anteriores, un agente contiene sensores y efectores, por lo que tiene sentido pensar
que un agente tiene, al menos, una actitud de conocimiento y, al menos una pro-
actitud.
Diferentes autores han descripto algunas actitudes y pro-actitudes para la
caracterización de los agentes. Corchado establece diferentes actitudes de
información y pro-actitudes:

Tiene relación con los sensores Creencias

Actitudes de
del agente. Cómo ve el mundo el
información
agente Conocimientos

Deseo

Intención

Obligación
Tiene relación con los efectores
Pro-actitudes Compromiso
del agente. Orienta las acciones.
Elección

Movilidad

Analicemos un poco las actitudes y pro-actitudes que se mencionan:

Creencias: es la información que un agente recibe de otros agentes (software,
personas).
Conocimiento o Evidencia: es la información que proviene de los sensores.
Deseo: son los fines que debería seguir el agente.
Intención: son las acciones básicas que el agente ejecutará en los próximos
instantes.
Obligación: es la conversión de los deseos en intenciones. Es la formulación de
acciones (intenciones) para concretar los fines (deseos).
Compromiso: es la necesidad de dotar al agente de una forma de necesidad de que
cumpla con sus intenciones en un tiempo determinado.
Elección: capacidad de la que se dota al agente sobre la posibilidad de optar por
diferentes soluciones o caminos.
Movilidad: algunos agentes software requieren de la capacidad de moverse de un
servidor a otro. Por supuesto, de tratarse de agentes físicos como los robots, la
movilidad es indispensable.

3.2.3. Arquitecturas de agentes

Las teorías formales sobre el desarrollo de agentes se pueden trabajar como
especificaciones formales (como estudios acerca de las propiedades de los agentes,
representación del agente y cómo debería razonarse sobre ellos).
Cuando nos referimos a la arquitectura de agentes son las estructuras y el medio
que llevan a las especificaciones a convertirse en un agente implementado.
Estas arquitecturas, abarcan:
 Cómo debe construirse el agente para que pueda poseer las propiedades
especificadas
 Las estructuras (que incluyen tanto software como hardware) que son
necesarias para cumplir con esas especificaciones.

Verificando el estado del arte en el desarrollo de sistemas de agentes, podemos

distinguir cuatro arquitecturas (tres estructuras puras y una mixta):
 Arquitecturas reactivas: como su nombre los indica, reaccionan directamente.
No poseen una representación simbólica del entorno en el que se encuentran.
Es una de las arquitecturas puras.
 Arquitecturas basadas en lógica: Una de las arquitecturas puras. La
manipulación de los datos se realiza mediante deducción lógica y a través de
fórmulas lógicas. El comportamiento del agente se establece mediante una
teoría.
 Arquitecturas deliberativas: Es la otra de las arquitecturas puras. Los agentes
contienen un modelo simbólico del entorno en el que se encuentran,
explícitamente representado y toman decisiones teniéndolo en cuenta.
 Arquitecturas Híbridas: Es la arquitectura mixta que mencionamos. Busca
combinar las arquitecturas previamente seleccionadas tomando lo mejor de
cada una de ellas para salvar las limitaciones de cada una de ellas.

En los próximos puntos nos explayaremos un poco en las arquitecturas

mencionadas teniendo en cuanta las actitudes y pro-actitudes mencionadas. Es
importante tener en cuenta que cada una de las arquitecturas es, de por sí, un tema
para desarrollar en la extensión de varios libros, lo que queda fuera del alcance de
éste trabajo. Sólo se tratarán los elementos necesarios para poder responder la
pregunta ¿Qué necesitamos para desarrollar cada tipo de agente?
 3.2.4. Arquitecturas reactivas

Las arquitecturas reactivas se caracterizan por ser arquitecturas que reaccionan

directamente a las condiciones del entorno. Son también llamados agentes estímulo
respuesta o simplemente de reflejo simple. Los hay con memoria y sin memoria.
Cuando estamos ante arquitecturas reactivas, la percepción en el agente induce una
acción que modificará el entorno, que un instante después, impactará nuevamente
en la percepción del agente generando una nueva acción. Este proceso, continúa en
un ciclo contínuo hasta que se cumpla el objetivo de diseño del agente.
Por lo general, las arquitecturas reactivas, no incluyen una representación simbólica
del mundo.

Tenemos ejemplos de arquitecturas reactivas:

 Sistemas de producción
 Sistemas de subsunción
 Máquinas de estados
 Redes monocapa
 Redes heteroasociativas
 Redes autoasociativas
 Tareas competitivas.

Veamos un poco más detalladamente cada uno de las arquitecturas. Está fuera del
alcance del presente trabajo un tratamiento detallado de cada una.
 3.2.4.1. Sistemas de producción

Los sistemas de producción forman parte de los agentes reactivos puros y se basan
en: percepciones del entorno, reglas de producción, y estrategias de control.
Un sistema de producción Z se define como:

Z=(D, P, C)

donde:

D: juego de hechos
P: es la base de producción o reglas de producción
C: la estrategia de control y resolución de conflictos.

El juego de hechos corresponde al vector de percepciones:

D= { s i }
donde:
si es el valor obtenido por un sensor

También es llamada memoria de trabajo o vector de sensado. La información

obtenida por los sensores se considera cierta.

Las reglas de producción toman la forma de pares ordenados donde el primer

elemento corresponde a la condición y el segundo elemento corresponde a la
acción.

P=¿i=1¿ n( c i , ai )
donde:
c i ∈ { condiciones }a i ∈ { acciones }

Las condiciones especifican las formas y los valores del entorno que se deben
cumplir antes de que las acciones puedan ser ejecutadas.
Por supuesto que las acciones son procedimientos que modifican el entorno
logrando que cambien o no las condiciones.
Las reglas de producción tienen la forma lógica modus ponen que se ve en la forma
de implicaciones: si condición entonces acción. (c i=¿ ai) y tienen las siguientes
características:
 Modular: Cada una de las reglas representa una pequeña parte del
conocimiento.
 Incremental: Pueden ir agregándose nuevas reglas
 Modificable: consecuencia de la característica modular, hace que sea
modificable.
 Transparencia: posibilidad de comprender claramente las decisiones que
toma el agente.
 Naturalidad para expresar el conocimiento: al expresarse en lógica formal de
primer orden.
Las reglas de producción se agrupan en tablas llamadas tablas de decisión.

La estrategia de controles un intérprete de reglas o máquinas de inferencia, esto es

buscar qué regla debe aplicar y controla la actividad de todo el sistema.

La máquina de inferencia ejecuta un ciclo constante de tres pasos, reconociendo,

resolviendo y actuando:
 Unificación: También llamada matching. En éste paso, se prueban los hechos
conocidos al momento con las reglas para ver cuáles son satisfechas. Una
regla se considera satisfecha cuando todas las condiciones se encuentran en
estado verdadero. Se recorre la matriz P en busca de las condiciones ci que
coincida con el vector de entrada. Es el que genera el conjunto de conflictos.
 Resolución de conflictos: Una vez satisfechas las condiciones, la resolución
de conflictos selecciona la regla que tenga la prioridad más alta de todas las
que quedaron satisfechas. Depende de la estrategia seleccionada, la
selección de prioridades. Son muchos los criterios que pueden aplicarse:
simplemente ordenada, la regla más utilizada, la regla menos utilizada, la
regla más genérica, la regla más específica, etc.
 Ejecución: Se ejecuta la acción cuya premisa es la regla seleccionada en el
paso anterior. El resultado de la acción puede ser: la modificación del entorno
(un hecho), una regla (que será añadida a la base de conocimientos
respetando el par ordenado condición-acción (c i=¿ ai) ) o un cambio de
prioridades para la próxima resolución de conflictos.

Las estrategias de inferencia pueden ser:

Encadenamiento de reglas: También se lo conoce como encadenamiento hacia
adelante. Este tipo de estrategias, se utiliza cuando las modificaciones producidas
en el entorno por una regla, coincide con el estado que activa las condiciones de
otra regla. Entonces, el algoritmo busca las reglas hasta que la modificación del
entorno no coincide con ninguna de las reglas existentes.
Encadenamiento de reglas orientado a objetivos: También se lo conoce como
encadenamiento hacia atrás- Éste algoritmo parte de la selección, por parte del
usuario de un objetivo. Luego, el algoritmo busca entre las reglas una que modifique
el entorno de manera que se pueda aplicar el objetivo. Y realiza el ciclo hasta que no
pueda encontrar otra regla generadora. En ese momento verifica con el usuario si es
la regla buscada.
Las desventajas de éste tipo de arquitectura, se basan en que como primera medida
deben tenerse en cuenta todas las posibilidades de condiciones necesaria para la
ejecución de las acciones. Puede darse una condición de encadenamiento infinito,
cuando se agrega nuevo conocimiento, puede suceder que el nuevo conocimiento
sea contradictorio con el preexistente o que el movimiento de prioridades haga que
algunas reglas nunca se ejecuten.
Los primeros sistemas expertos se han desarrollado utilizando sistemas de
producción. Actualmente muchos de los sistemas de decisión se desarrollan en
bases a sistemas de producción.

3.2.4.2. Sistemas de subsunción

Roodney Brooks, a mediado de la década del 80, introdujo la arquitectura de

subsunción. Propuso las siguientes tesis [6]:

 El comportamiento inteligente puede generarse sin la necesidad de una

representación simbólica del entorno.
 Puede haber comportamiento inteligente sin un razonamiento abstracto.
 La inteligencia surge como propiedad de algunos sistemas complejos.
Brooks se basó en la característica divide y vencerás eliminado el problema
rompiéndolo en muchos problemas más sencillos.

La arquitectura de subsunción se basa en una metodología de capas [6]. Es una

jerarquía de comportamientos y cada comportamiento es una estructura sencilla
estilo regla.
Cada capa compite para controlar el comportamiento del agente. Es un método
paralelo y distribuido para conectar sensores y actuadores en los agentes. Donde
cada capa puede inhibir a la capa inferior. Las entradas pueden ser suprimidas y las
salidas pueden ser inhibidas.
La característica de éste tipo de arquitecturas, es que las funciones de los niveles
superiores subsumen a las funciones de los niveles inferiores. Lo interesante es su
robustez. Tiene un punto débil: la capa más baja. La capa inferior puede seguir
funcionando si las capas superiores fallan. Lógicamente es posible que el agente no
pueda cumplir con sus objetivos de diseño. Si falla la capa inferior, aunque el resto
de las capas funcionen correctamente, el agente no podrá hacer nada porque no
habrá ningún tipo de acción.

Ilustración 1 Esquema Subsunción

Allen ha sido el primer robot construido por Brooks utilizando la arquitectura de

subsunción. El robot tenía como sensores un sonar y un odómetro. Fuera del robot
una máquina LISP simula la arquitectura de subsunción.

La primera capa permite al robot esquivar los obstáculos. Allen se mantendrá

estático hasta que el sonar reciba un pulso que hará que el robot se aleje del objeto
que se acerca al sonar con una fuerza proporcional al cuadrado de la distancia.

La segunda capa hace que el robot navegue aleatoriamente durante 10 segundos o

a una dirección deseada. Ese deseo se anula con el instinto de evitar los obstáculos.
Los reflejos del nivel inferior siempre se mantienen operativos.

La tercer capa hace que el robot observe usando el sonar lugares distantes y tratar
de dirigirse hacia ellos. Esta capa se encarga de monitorear el proceso usando el
odómetro generando la dirección deseada cuando la capa de deambular se había
activado.
Las capas inferiores ejecutan los comportamientos más primitivos.

Podemos verlo en el siguiente gráfico:

 Ilustración 2 Esquema Allen

Características de una arquitectura de subsunción:

No hay modelo interno del mundo real: no hay memoria compartida entre los niveles,
no hay mayor comunicación entre los niveles más que la inhibición o la supresión.
Independencia de módulos: Cada módulo tiene acceso sólo a los sensores sobre los
que tiene incumbencia.
Robustez en el desarrollo: El desarrollo permite un funcionamiento óptimo inmerso
en el entorno para el que fue diseñado y la falla de una capa no implica la falla de
todo el sistema
Escasa programación: Los módulos se programan de manera sencilla y
generalmente a nivel de firmware o electrónico.
Ineficiente ante condiciones inesperadas: Cuando las condiciones se alejan de las
condiciones de diseño, pierde capacidad de recuperación.
Razonamiento en tiempo de diseño/compilación: Como se mencionó previamente, la
programación del sistema, no incluye conocimiento simbólico del entorno y las
decisiones que toma el agente, requieren que se piensen las condiciones en el que
el mismo se encontrará inserto, de manera que la inteligencia del sistema, se
plantea al momento de diseño/compilación.
Excelente velocidad de respuesta: Dado que su procesamiento interno es sencillo, y
muchas veces a muy bajo nivel, tiene una altísima velocidad de respuesta.

Un ejemplo de aplicación de éste sistema, lo constituye el sistema de exploración

“Steels’ Mars” propuesto por Roseschein y Kaebling. Con la arquitectura de
subsunción, logra un funcionamiento casi óptimo en la recolección de rocas en el
planeta Marte.
El objetivo del sistema es explorar un planeta distante, y en particular, recolectar
muestras de rocas.
Condiciones: La ubicación de las rocas no es conocida. Se sabe que las rocas se
encuentran agrupadas.

Acciones:
1. Si tengo rocas y estoy en la nave: suelto las rocas
2. Si tengo rocas y no estoy en la nave: voy a la nave
3. Si localizo muestras: cargo muestras.
4. Si no se cumplen las condiciones anteriores: deambulo aleatoriamente

3.2.4.3. Máquinas de estados

Las máquinas de estado finito (autómatas finitos) se originaron como modelos

matemáticos. Son una poderosa herramienta para el trabajo con compiladores,
lenguajes formales y circuitos secuenciales. También es una buena herramienta
para el diseño de agentes reactivos.

Todas las máquinas de estado finito tienen un conjunto de estados, un estado inicial
y una función de transición que a cada conjunto formado por un estado y por una
percepción, le asigna un estado siguiente. Las máquinas de estado tienen una
capacidad de memoria limitada, provocada por los estados anteriores.

E.F.Moore, estableció la bases de las máquinas de estado en 1956 y definió la

máquina de estados que lleva su nombre como sigue [7]:
La definición formal de una máquina de estados o autómata finito es una 5-tupla:

(Q, Σ, q0, δ, F)

donde:
Q es un conjunto finito de estados,
Σ es un alfabeto finito,
e0 es el estado inicial,
δ es una función de transición y
F es un conjunto de estados finales (también denominado de aceptación).

Como puede verse en la definición, las máquinas de estados tienen, principalmente,

estados y transiciones.
Estado: Cada etapa por la que pasa un circuito secuencial se denomina estado. En
cada estado, el circuito almacena un recuerdo de su historia pasada. Un agente
siempre se encuentra en un estado del conjunto de estados finitos.
Transición: es el pasaje entre un estado y otro.

La operación de un agente controlado por una máquina de estados es:

 En un instante dado, el agente se encuentra sólo en un estado del conjunto
de estados posibles.
 El agente acepta un número finito de entradas que activa las transiciones
 El estado inicial con la transición llevan al agente a un nuevo estado. Por lo
que puede verse que es determinista (el estado destino está determinado por
el estado inicial y la transición provocada por las entradas).
La máquina de estado funciona como si fuera algún tipo de memoria del agente.

Ilustración 3 Agente con máquina de estados

Hay dos representaciones muy usadas para la representación de una máquina de

estados: el grafo dirigido y la tabla de transiciones o matrices de estados.

Veamos un autómata finito definido sobre un alfabeto

Σ = {0,1}
Q = {e0, e1}
e0 es el estado inicial
 δ(e0, 0) = e1
δ(e0, 1) = e0
δ(e1, 0) = e0
δ(e1, 1) = e1
e0 es el estado de aceptación

Representación como diagrama de estados.

Ilustración 4 Diagrama de estados

Representación como tabla de transiciones

Hay dos maneras de representación:

0 1

->*s1 s2 s1

s2 s1 s2

la flecha indica el estado inicial y el asterisco representa el estado final.

origen símbol Destino

o

q∈Q σ∈Σ δ(q,σ)∈Q

 s1 0 s1

s1 1 s2

s2 0 s1

s2 1 s2

Otros dos ejemplos de máquina de estados en especial es la Máquina de Turing la

máquina de Mealy.

Máquina de Turin

Es un modelo computacional que opera de manera automática, tomando su entrada

de una cinta y expresando su salida en la misma cinta.
Se puede pensar una máquina de Turin como las viejas cintas que usaban las
computadoras de los años 50. Con un cabezal lecto-esctritor. La funcion del cabezal
es: leer la cinta, borrar el contenido anterior y escribir el nuevo contenido.
Operaciones permitidas:
 Mover el cabezal a derecha e izquierda (o la cinta según la implementación),
 Leer un valor.
 Borrar y escribir otro valor.
El nuevo valor se determina usando una tabla de estados:
(estado actual de la máquina, valor leído de la cinta) (nuevo estado, nuevo valor,
dirección)
La memoria es la cinta que se ha mencionado y se divide en celdas, donde se
pueden escribir y leer símbolos.
Al principio, todas las celdas se encuentran en blanco (se crea un símbolo especial
en el alfabeto para representar ese espacio vacío)
El agente se encuentra en el estado X, el cabezal ubicado en la posición P. Lee el
símbolo S. Según la tabla de estados, debe reemplazar ese símbolo por el T. Mueve
el cabezal a izquierda o derecha (según lo establecido en la tabla de estados). El
agente queda en estado Y.

Ejemplo (tomado de Wikipedia Máquina_de_Turing):

Analicemos la siguiente máquina de Turing:

Σ = {0,1}
El 0 representa el símbolo "en blanco"
Q = { e0, e1, e2, e3, e4, e5 }
e0 es el estado inicial

La tabla de transiciones es:

Estado Símbolo Símbolo Movimiento Estado

inicial leído escrito cabezal final

e0 1 0 D e1

e1 1 1 D e1

e1 0 0 D e2

e2 0 1 I e3

e2 1 1 D e2

e3 1 1 I e3

e3 0 0 I e4

e4 1 1 I e4

e4 0 1 D e0

El objetivo es duplicar la cantidad de 1 con un 0 en el medio. Si tenemos 11

devolverá 11011, si hay 1110111.

El funcionamiento de una corrida. Podemos ver resaltada la posición del cabezal.

| Estado Cinta
Paso

1 e0 11
 2 e1 01

3 e1 010

4 e2 0100

5 e3 0101

6 e4 0101

7 e4 0101

8 e0 1101

9 e1 1001

10 e2 1001

11 e2 10010

12 e3 1001
1

13 e3 10011

14 e4 1001
1

15 e0 11011

Parada

Maquina de Mealy

La máquina de Mealy es un tipo especial de máquina de estados en donde, a cada

transición se obtiene una salida.

Analizando formalmente la máquina de Mealy, podemos decir que es una 6-tupla:

(Q, Σ, Γ, ∂ , ⍵, q0)

donde:
Q es un conjunto finito de estados,
Σ es un alfabeto finito,
Γ es un conjunto finito llamado alfabeto de salida,
∂ es la función de transición,
⍵ es la función de salida, definida ⍵:Q x Σ -> Γ,
q0 es el estado inicial.

A diferencia de las máquinas de estado finito comunes donde se aceptan o se

rechazan estados, mapean estados de entrada en estados de salida.

3.2.4.4. Redes

El campo de estudio sobre las redes es extremadamente amplio y aquí se

mencionarán los puntos necesarios para poder responder a las preguntas
necesarias para poder diseñar un agente que responda a éste tipo de arquitectura.
Antes que nada, el concepto de redes involucra varias unidades y distintos tipos de
interconexión entre ellas. El mismo concepto trata sobre paralelismo de
procesamiento ya que cada unidad podría no solo ejecutarse en un proceso
separado, sino que también podrían ejecutarse en procesadores y circuitos
integrados diferentes, lo que está favorecido por la integración a gran escala (VLSI).

Buscando una redacción más formal: Una red es un modelo matemático esencial y
masivamente paralelo realizado por unidades extremadamente simples. Cada
unidad tiene capacidad de almacenar conocimiento obtenido de manera
experimental, y que lo usa a medida de que lo obtiene.

Los diseños de las redes, tomando como ejemplo las redes neuronales [8], basan su
funcionamiento en un modelo con la topología del cerebro, en algunos aspectos:
 El conocimiento se adquiere durante el proceso de aprendizaje.
 Las unidades (neuronas) se interconectan a través de conexiones (sinapsis)
y, cada una de éstas, tiene un peso asignado. El valor de esos pesos
configuran la memoria de la unidad.
 Hay dos tipos de conexiones: las activadoras y las receptivas.

El implementar en un agente, éste tipo de tecnología, importa ciertos beneficios:

 Aprendizaje Adaptativo: Utilizando ejemplos y valores esperados de esos
ejemplos, el agente potenciado con redes neuronales, aprende a realizar las
tareas modificando el peso de sus sinapsis.
 Adaptabilidad: Como consecuencia del punto anterior al adaptar sus pesos
sinápticos, pueden adaptarse de manera más sencilla a los cambios en el
entorno.
 No-linealidad: El alto paralelismo establece la no linealidad de la operación en
los agentes operados por redes neurales y es bueno para el procesamiento
de entradas de tipo analógico. La no-linealidad se aplica mucho en el
procesamiento de señales de audio (reconocimiento de voz) y de video
(reconocimiento de imagen)
 Auto-organización: La red, en la etapa de aprendizaje, se auto-organiza al
establecer los pesos de cada una de sus conexiones sinápticas.
 Tolerancia a fallos: Las redes neuronales son, por conformación, tolerantes a
fallos. Cuanto más masiva es la red, más tolerante a fallos es. Su por algún
motivo, hubiera una destrucción parcial de unidades de la red, habría una
degradación en la velocidad de funcionamiento, en la estructura de la red,
pero seguiría funcionando.
 Mapeo entrada-salida: La red neural es básicamente un sistema reactivo, hay
un mapeo entre las entradas y las salidas. No es un mapeo sencillo y directo
ya que está influenciado por los pesos en las conexiones sinápticas.
 Operación en tiempo real: El paralelismo del diseño, unido a las tecnologías
de procesamiento paralelo hace a las redes neuronales muy rápidas para su
operación en tiempo real.
 Fácil inserción dentro de la tecnología existente: Es sencillo programar ahora
chips especializados para uso de redes neuronales.
 Respuesta evidencial: Las redes neuronales son evidenciales. No sólo
permiten el reconocimiento de patrones sino que pueden establecer un
intervalo de confianza sobre la decisión tomada.
 Uniformidad de análisis y diseño: No importa el dominio de aplicación en el
que se utilicen redes neuronales, se utilizará la misma notación en todos.
Siempre se usarán neuronas o nodos en todas las reden neuronales.
 Analogía con la biología: No se necesita mucha explicación para explicar la
analogía con las estructuras biológicas ya que éste tipo de tecnología, se
inspiró en el cerebro.
 Ilustración 5 Modelo de estructura de sistema nervioso central

La mayoría de las redes de las que se trabajan e investigan son las redes
neuronales. De manera que analizaremos el modelo de red neuronal.

Modelo no-lineal de una neurona. El perceptrón

En 1957 Frank Rosenblat, en el laboratorio aeronáutico de Cornell, desarrolló el

algoritmo del perceptrón.
En realidad, cuando se pensó el perceptrón, no se pensó como una pieza de
software, sino como una máquina. Inicialmente se implementó como un programa en
una IBM 704, pero en seguida se desarrolló el "Mark 1 perceptron" designada para
reconocimiento de imágenes. Tenía una matriz de 400 células fotovoltaicas
conectadas a las neuronas. Los pesos se ajustaban usando motores eléctricos
operando sobre potenciómetros.
Como el perceptrón demostró si dificultad en reconocer cierto tipo de patrones, cayó
en desuso y puso paños fríos durante bastante tiempo sobre la línea de
investigación de redes neuronales.

Primero veremos un esquema de bloques para comprender las partes.

 Ilustración 6 Modelo de neurona
Donde:
e0 —> es la entrada o señal de entrenamiento
E = {e1, e2,…, en} —> es el vector de entradas, pueden provenir del entorno o de
otras neuronas.
W={w1,w2,…,en} —> es el vector de pesos que se irá modificando a medida que se
entrena a la neurona.
∑ —> es la función sumadora que se encarga de realizar la suma ponderada.
φ —> es la función de activación.
y—> es el valor de salida.

Lo sencillo de la red neuronal o de una neurona es su constitución: un sumador

ponderado. Es fácilmente implementable por medios electrónicos.

Cada entrada puede ser activadora o inhibidora según el peso que le sea asignado.

Función de activación

Modelo determinístico: no existe azar en los resultados de la función

 Función escalón

{
φ (v )= 1→ v ≥ 0
0 → v <0

 Función lineal
 {
1
1→ v ≥+
2
φ (v )= v →− 1 > v > +1
2 2
1
v → v ≤−
2

 Función sigmoidea
1
φ (v )= −av
1+ e
donde a = es la pendiente de la función de activación

 Función tangencial hiperbólica

e av −e−av
φ (v )=
e av + eav
al variar el valor de a, se varía la pendiente de la función de activación

Modelo estocástico: Hay una probabilidad asociada a los resultados de la función

X=
{+1 con probabilidad P(v)
−1con probabilidad 1−P (v )

1
P( v)= −v
( )
1+e T

Arquitectura de una red neuronal

1) Perceptrón de capa simple

Las primeras redes neuronales fueron de éste tipo. Por lo general sirve como
clasificadora de padrones.

2) Perceptrón multicapa

Las redes multicapa sin feedback son aquellas en las la señal se propaga hacia
adelante sin ningún tipo de bucle. son estáticas y sin memoria ya que no depende de
un estado previo de la red. No presenta ningún bucle en la red.

3) Función radial básica

Es una red de más de dos capas cada unidad de las capas ocultas emplean una
función de base radial como activadora (como una gaussiana). Calculan su salida en
función a la distancia a un punto tomado como centro.
Las capas de salida tienen distinta función de activación ya que tienen distintos
objetivos.

Las funciones multirradiales, pueden ser:

  Gaussiana
2

∅ ( r )=e−(εr)
 Multicuadrática
∅ ( r )=√ 1+( εr)
2

 Multicuadrática inversa
1
∅ ( r )=
√ 1+(εr)2
 Spline de capa delgada
k
∅ ( r )=r con k=1,3,5 , …
k
∅ ( r )=r ln ⁡(r ) con k=2,4,6 ,…
 Spline poliarmónico
2
∅ ( r )=r ln ( r )

4) Redes competitivas

Stephen Grossberg desarrolló las ideas que llevó a éste tipo de redes.
En los casos anteriores, es posible que todas las salidas de la red se encuentren
activas a la vez. En el caso de las redes competitivas, sólo una unidad de salida se
encuentra activa a la vez. Las unidades de salida compiten entre sí ara activarse y
será la única activa.
Si bien todas las neuronas tienen acceso a todas las señales de entrada, cada una
de las neuronas tiene mayor injerencia sobre un grupo de entradas.
Hay dos tipos de competición:
 Dura: sólo una neurona activa la salida
 Blanda: una neurona activa fuertemente su salida, pero las neuronas vecinas
comparten un poco de los recursos.

5) Redes autoorganizativas de Kohonen

En 1982 Teuvo Kohonen presentó un modelo de red neuronal con capacidad de

formar mapas de características (tomó de modelo al cerebro) ordenando
matricialmente las neuronas.
Es un tipo especial de red competitiva en donde, además, se tiene en cuenta la
posición física de las neuronas. La localización en el mapa espacial de una neurona,
determinaría una característica particular de los datos de entrada.
6) Redes de Hopfield

Es una red neural recurrente desarrollada por Hopfield en 1982 [9]

y funcionan como
memoria asociativa.
Los elementos de la red de Hopfield son binarios. Tienen dos estados, activo (si
pasa el umbral) o inactivo, (si no pasa el umbral).
La salida de cada neurona se conecta a la entrada de todas las demás excepto
consigo misma.

7) Modelos ART (Teoría de resonancia adaptativa)

Grossberg y Carpenter armaron un modelo de red neuronal artificial que trata de

imitar la manera en que el cerebro procesa la información.
La teoría de resonancia adaptativa se basa en buscando un equilibrio entre:
Estabilidad del aprendizaje (retener la información aprendida) y la Plasticidad del
aprendizaje (adquirir nuevos conocimientos) utilizando realimentación de las
neuronas competitivas de la salida.
Tiene dos capas, la capa de entrada, encargada de comparar similitud y la capa de
salida, con neuronas competitivas. La neurona ganadora inhibe al resto. Es posible
agregar una capa de preprodesamiento para acondicionar las entradas.
Hay un parámetro de vigilancia que dice cuán semejante debe ser la entrada con la
clase seleccionada. Es un valor ubicado entre 0 y 1. Si x es muy cercano a cero, se
agrupan muchas entradas en la misma clase (estabilidad). Por otro lado, si x se
acerca mucho a uno habrá muchas clases (plasticidad)
Este tipo de redes tiene dos tipos de pesos: W es el peso normal como en el normal
de las redes y T que es un peso de realimentación:

T
W=
∑ T +γ
donde γ es un parámetro que vale, por lo general 0.5

Tiene cuatro fases: Inicialización, Reconocimiento, Comparación y Búsqueda.

El diagrama de flujo (tomado de wikipedia: Dilema de la Estabilidad y Plasticidad del

Aprendizaje)
Aprendizaje de las redes neuronales

Básicamente, los algoritmos de aprendizaje pueden separarse en dos grandes

grupos: supervisado y no supervisado[10].
El aprendizaje es el proceso por el cual una red neuronal modifica sus pesos en
respuesta a una información de entrada. Los cambios que se producen durante el
mismo se reducen a la destrucción, refuerzo, debilitación y creación de conexiones
entre las neuronas.
En el aprendizaje supervisado, hay un entrenador que asiste a la red neural en el
proceso de aprendizaje con pares estímulo asignado/respuesta deseada, guiándola
en las primeras decisiones, etc.
En el aprendizaje no supervisado No se le entregan a la red ejemplos con sus
respuestas. Es fuertemente reglado. Se programa al agente con un conjunto de
reglas que le permite a la red, y por lo tanto al agente, aprender entre los patrones
que más se repiten. Luego del período de aprendizaje, la red podrá reconocer ese
tipo de patrones.

Aprendizaje por Corrección de error

Los pesos de las conexiones de red son ajustados en función de la diferencia entre
los valores deseados y los obtenidos. Y se realiza el proceso con cada neurona
recorriendo la capa hacia atrás.
Rosenblatt en 1958, desarrolló este modo de aprendizaje para el perceptrón: para
cada neurona en la capa de salida, se calcula el error entre la salida real y la salida
deseada. Ese error lo denotamos con α.
yi es la salida obtenida en la neurona de salida
yj es la salida de la neurona de la capa precedente
dj es la salida deseada
Δwji es la corrección al peso

Δwji = αyi(dj - yj)

Aprendizaje por error cuadrático medio

También se la conoce como regla Delta. Es un paso más adelante que el modelo
aprendizaje por corrección de error. Como el caso anterior también se maneja con la
diferencia entre la salida deseada y la obtenida. Solo que se toma globalmente, se
tienen en cuenta todas las neuronas de la red. Al tomarse globalmente, puede
suceder que la corrección de una neurona anule la corrección de otras. Para evitar
que los errores de las distintas neuronas se anulen, se trabaja con los errores
cuadráticos. Y se busca, como en el caso anterior minimizarlo.
Es lógico suponer que cuanto más información se tenga de los errores que se
propagan en la red, más rápido se entrena la red. Por eso se toma el entrenamiento
a nivel global de la red.

Algoritmo de retropropagación

Se debe éste algoritmo a Rumelhart. Es una generalización y perfeccionamiento de

la regla delta enunciada en el punto anterior. Es un algoritmo de entrenamiento
supervisado cuyo objetivo es minimizar el error.
Como es supervisado, es necesario un conjunto de valores de entrenamiento en
donde de describa el vector de entrada y el valor que se espera para la salida de ese
vector.

El algoritmo debe seguir los siguientes pasos:

 Determinar los conjuntos de valores de prueba ¿ i=1 ¿ n {⃗ X i , si }

 Por cada uno de los valores de prueba, calcular el valor de salida de la red
aplicando la entrada: ⃗X i . Se obtiene la salida calculada ci
 Se calcula el error producido por esa entrada

n
1
E (⃗
Xi, ⃗ W c+1 ) =
W c ,⃗ ∑ ( s −c )2
2 i=1 i i

donde:

⃗
Xi Vector con los valores de las entradas de cada
neurona.
⃗
Wc Vector de pesos de las entradas de las neuronas de
una capa.
⃗
W c+1 Vector de pesos de las entradas de la capa siguiente
si Salida ideal de las neuronas
ci Salida calculada de las neuronas
  Calcular las derivadas parciales del error considerando los pesos de la capa
de salida⃗
W c+1
 Calcular las derivadas parciales del error considerando los pesos de la capa
oculta anterior⃗
Wc
 Se ajustan los pesos de cada neurona para le siguiente paso, según la
fórmula, para reducir el error
⃗
W c =⃗
p+1
W c +⃗
p
∆W

⃗
∆ W =δ i α [ ∂ f i ( e)
∂e i
x ]
δ i=( si −c i )
y α =Coeficiente de aprendizaje (éste valor afecta la velocidad de aprendizaje).
 Se repite todo el proceso para todos los elementos del vector de pruebas.

Aprendizaje por refuerzo

Si bien éste tipo de aprendizaje es supervisado, se diferencia de los anteriores

porque no poseen un vector de entrenamiento. En el aprendizaje por refuerzo,
cuando se entrena la red neuronal, no se le dice cuál es la salida deseada. El
supervisor del entrenamiento se encarga de, mediante una señal, si la salida es la
deseada. La señal debe ser +1 si la red tuvo éxito o -1 si la salida fue incorrecta. De
acuerdo a la señal, deben ajustarse los pesos de las neuronas para que la respuesta
de la red se adapte para cumplir con los objetivos de la red. Para ajustar los pesos,
por lo general, se usa un esquema de probabilidades.
Podemos nombrar tres buenos ejemplos de aprendizaje por refuerzos:
 Eurístico crítico adaptativo: Sutton en 1992 desarrolló el aprendizaje por
refuerzo adaptativo. En ésta aproximación, se utiliza heurísticas para
determinar la función de evaluación. El crítico proporciona una información
evaluativa. No le entrega instrucciones.
El algoritmo desarrollado por Sutton, basa su estructura en dos componentes:
el elemento de búsqueda asociativa (ASE - Asociative search element) es el
encargadode aparear los vectores de entrada con el vector de salida de la
red; y el elemento crítico adaptativo (ACE - Adaptive Critic Element)
propiamente dicho que es el que otorga las señales de refuerzo interno para
el primer elemento. Y que permiten tener un análisis [11].
 Algoritmo lineal de recompensas y penalización: Desarrollado por Narendra y
Thathacher en 1974. Se aplica generalmente a redes de dos capas con una
función de activación estocástica. LR-P (lineal reward-penalty).
En este tipo de algoritmo podemos determinar dos tipos: el noasociativo,
donde el aprendizaje consiste en encontrar la acción óptima sin asociarla al
 estímulo; y la asociativa se intenta mapear los estímulos con las respuestas
aprovechando información adicional del ambiente.

Aprendizaje estocástico

Realiza cambios aleatorios sobre los pesos de las conexiones buscando acercarse
al objetivo de la red. Se establecen una función que se asemejaría a un estado de
energía de la red, una función de energía. El entrenamiento consiste en realizar
cambios aleatorios. Luego realizar el cálculo de la función de energía. Si la energía
disminuye, el cambio se toma como válido. En caso de que la energía sea la misma
o mayor, se acepta el cambio (o no) según una función fe probabilidades
preestablecida para la red.
Éste tipo de red utiliza el temple simulado (simulated annealing) para evitar que la
función de probabilidades caiga en mínimos locales.
En 1984, Hinton ideó la red denominada Boltzmann Machine (une éste tipo de
aprendizaje con el Hebbiano).
En 1986, Messner y Szu en 1987 inventaron la máquina de Cauchy que usa la
distribución de Cauchy para generar los saltos aleatorios tanto como los pasos a los
nuevos estados.

Aprendizaje asociativo o Hebbiano

En 1949 el neuropsicólogo Donald Hebb, en su libro The organization of behaviour

(1949 pag 62) introduce la regla de Hebb o el postulado de aprendizaje de Hebb. En
donde se resume que las células que se disparan juntas permanecerán unidas.
Heb dice:"Cuando el axón de una célula A está muy cerca de excitar una célula B y
repetidamente o de manera persistente toma parte en el disparo de ésta, algún
procedimiento de crecimiento o cambio metabólico tiene lugar en una lo dos células
de manera que la eficiencia de A como disparador de la célula B se incrementa"
Analizando este concepto biológico, lo podemos extrapolar al contecto de los
agentes, podemos enunciar las siguientes reglas:
1) Si dos neuronas están interconectadas y se activan simultáneamente entonces, la
fuerza se incrementa. Es decir, el peso asociado a esa sinapsis aumenta,
2) Por contraposición a la regla anterior, si dos neuronas interconectadas no se
activan simultáneamente, es decir, una no activa a la otra, la fuerza de esa sinapsis
se debilita. Es decir, el peso asignado a esa sinapsis disminuye.
Hay autores como Felippetto de Castro [12] que consideran una tercera regla:
3) La modificación de los pesos sinápticos tienden a cooperar.
En lo que respecta a éste trabajo, se considera qu esta tercera regla es un derivado
de la primera regla, al igual que la segunda regla podría considerarse el
complemento de la primera regla.
Según Simon Haykin[13] la definición de una sinapsis hebbiana es aquella que "usa
un mecanismo dependiente del tiempo, localizado y fuertemente interactivo que
incrementa la eficiencia sináptica como función de la correlación entre las
actividades pre y post sinápticas"
El aprendizaje hebbiano es un tipo de entrenamiento no supervisado y auto-
controlado. Esto permite descubrir patrones característicos, relaciones,
características y posibles correlaciones de los datos de entrada sin necesidad de la
presencia de un tutor.
Es un proceso de aprendizaje auto-organizado consistente en modificar los pesos de
las neuronas iterativamente de acuerdo a reglas preestablecidas respondiendo a los
valores de entrada, buscando cumplir con los objetivos de la red.
nos perite definir las siguientes ecuaciones para el aprendizaje.

Aprendizaje competitivo

Es un aprendizaje que puede ser supervisado o no supervisado en donde, lo que se

debe hacer durante el aprendizaje competitivo es crear una regla que pueda ser
aplicada a la capa de entrada de forma que se le asigne a cada una de las
neuronas, diferentes porciones del dominio de entrada.
Es como si se tomara el conjunto de valores de entrada y se separaran en
subconjuntos disjuntos entre sí de tal manera que la suma de todos los subconjuntos
constituyan el conjunto inicial. Podemos decir que las neuronas tienen funciones
especializadas. Es una imitación de las áreas de procesamiento del cerebro.
Kohonen, en 1989 desarrolló el Aprendizaje de cuantificación vectorial (Learning
Vector Quantization — LQV)
El espacio de entradas se divide en regiones y se define el vector de pesos que
caracteriza a cada región.

3.2.4.5. Tareas competitivas

En éste tipo de agentes, el agente debe decidir qué acción realizar entre todas las
posibles, seleccionando la que proporciona un mayor valor de activación.
Cuando se aplica tareas competitivas para el control de un agente, se habla de usar
refuerzos positivos. Puede aplicarse tanto el algoritmo minimax-Q como el algoritmo
Q-Learning para maximizar el beneficio del agente. Se llama competitiva porque se
utiliza en los sistemas multi-agentes tratando de maximizar su propio beneficio
buscando minimizar el de los otros agentes. Pero en ésta sección nos interesa su
arquitectura en solitario. Utiliza refuerzos positivos para optimizar el comportamiento
del agente fortaleciendo los pares estado-acción que maximicen el beneficio del
agente.

El algoritmo Q-Learning permite que el agente aprenda a partir del conocimiento

obtenido por los sensores desde el exterior.

Cuando el agente aprende tiene cuatro elementos:

{e0, a, e1, r}

donde

e0: es el estado inicial del agente,

a: acción realizada por el agente,
e1: estado al que llega le agente y
r: es el refuerzo que recibe el agente por la acción.

Se define una función Q(e, a) que es la función que mapea el estado con la acción
que realiza el agente, y devuelve el refuerzo.
Ilustración 7 Algoritmo de Q-Learning
 3.2.5. Arquitecturas basadas en lógica

Los agentes con arquitectura basada en lógica, toman sus decisiones basado en
reglas y conceptos lógicos. Tienen una representación de su estado interno, sus
creencias según las actitudes mencionadas, utilizando un conjunto de sentencias
lógicas.

Hay varios tipos de lógicas:

 Lógica proposicional y de predicados
 Lógica modal
 Lógica deóntica
 Lógica temporal
 Lógica epistémica
 Lógica Doxástica
Desde la época de los filósofos griegos que se tratan y analizan las operaciones
lógicas.

Las ventajas de estas arquitecturas es que las fórmulas lógicas representan el

conocimiento de forma clara y elegante.
Las desventajas que presenta es la complejidad de representación del mundo real
como entidades y procesos.

3.2.5.1. Lógica proposicional y de predicados

Antes que nada definiremos lo que es una proposición: es cualquier oración

afirmativa de la cual pueden decirse verdadero o falso, pero nunca ambos.
La lógica proposicional analiza las inferencias tomando a las proposiciones como
elementos base.
Nos permite razonar en base a fórmulas basadas en verdadero y falso. Así es
posible expresar frases en base a operadores booleanos: not(¬), and (˄), or (˅) y
implicación(=>) y los cuantificadores: Para todo ( ∀ ) y existe al menos un ( ∃). Los
estados del sistema se definen utilizando operadores lógicos y proposiciones.
La lógica de predicados analiza la inferencia en base a lo que se afirma de cada
objeto dentro de la proposición.
Un predicado es una aplicación de una función booleana cuyos argumentos pueden
ser, o no, expresiones no booleanas. Cuando deben expresar propiedades o
relaciones entre objetos, se pueden utilizar predicados.

El lenguaje Prolog es un lenguaje definido en la década del 70 por Alain Colmerauer

de la Universidad de Marsella.
Es un lenguaje basado en hechos y reglas:
Los hechos son predicados de la forma
Cabeza :- Cuerpo (La cabeza es verdad si el cuerpo es verdad)
persona(juan) o lo que es lo mismo: persona(juan) :- true
Si consultamos:
?- persona(juan)
el sistema responderá
Yes
las reglas son sentencias condicionales
persona(juan) :- hombre(juan)
Quiere decir si juan es hombre, entonces juan es persona

No es intención de éste trabajo desarrollar extensivamente el lenguaje Prolog, pero

se aconseja verificar los sitios enunciados en la bibliografía [14] [15] [16] [17] [18] [19] [20].

Si bien puede programarse éste tipo de lógica con muchos tipos de lenguajes de
programación, el Prolog es una excelente herramienta al momento de utilizar lógica
proposicional o lógica de predicados.

3.2.5.2. Lógica modal

La lógica modal[21] agrega operadores modales a la lógica proposicional de manera

que permitan analizar diferentes modos de verdad: posiblemente cierto y
necesariamente cierto.
Si bien el estudio de la lógica modal se remonta a la época de Aristóteles y luego en
la edad media, fue en la década del 60 que Saul Kripke, en sus trabajos “Semantical
analysis of modal logic I:Normal propositional calculi” (1963) y “Semantical analysis
of modal logic II: Non-Normal Modal propositional Calculi” (1965) aporta las
herramientas básicas para el análisis semántica de la lógica modal. Establece la
semántica de los mundos posibles.
En los agentes con arquitectura lógica que usan lógica modal, podemos asociar la
creencia a posiblemente cierto y el conocimiento a necesariamente cierto.

En la lógica modal, se agregan dos operadores cuyos símbolos son los siguientes:

es necesario que

es posible que

Por supuesto que en la lógica modal clásica es posible definir uno en función del
otro:
Los axiomas más conocidos son:

K (p => q) -> ( p => q) Si es necesario que p implica q,

entonces es necesario que p
implica que es necesario q
(propiedad distributiva)

ToM p => p Si es necesario p, entonces p

(propiedad reflexiva)

4 p => p Si es necesario p, entonces es

necesario que p sea necesario
(propiedad transitiva)

5 p => p Si es posible p, entonces es

necesario que sea posible p.
(propiedad euclídea)

B p => p Si p, entonce es necesario que

sea posible p (propiedad
simétrica)

3.2.5.3. Lógica deóntica

En éste tipo de lógica, el agente agrega un nuevo operador que es el de

obligatoriedad.
Si utiliza ésta lógica, el agente se encontrará con proposiciones que estará obligado
a realizar. Reglas que obligatoriamente debe cumplir.
Von Wright, en 1951 en su trabajo Deontic Logic desarrolla la lógica modal deóntica
teniendo en cuenta lo prohibido, lo permitido y, por supuesto, lo obligatorio.
Sus supuestos son los siguientes:
  Las consas obligatorias, permitidas o prohibidas son actos que puede realizar
un agente.
 Es el agente que realiza la acción el que le da el valor de verdad con la
ejecución del acto.
Tomaremos para éste trabajo sólo una primitiva: Obligatorio ya que lo permitido es
una negación de la obligatoriedad de la negación de la acción (una afirmación
compleja que se verá en unos instantes) y lo prohibido es una obligación de la
negación de la acción.
Los símbolos que utilizaremos serán:

O p será obligatorio

Veremos cómo definir lo prohibido a partir de lo obligatorio.

Analicemos la siguiente afirmación:
“Está prohibido estacionar”
Se puede decir que es obligatorio no estacionar. De manera que la prohibición es la
obligación de la negación de la acción.
En símbolos:
O(¬p)
Ahora, basándonos en la afirmación anterior, se definirá permitido.
“Está permitido estacionar”
Si una acción está permitida es porque no está prohibida. Se puede decir, entonces,
“No está prohibido estacionar”.
Basándonos en la definición de prohibición podemos decir: “No es obligatorio no
estacionar”. Esto es una negación de la obligatoriedad de la negación de la acción.
En símbolos:
¬O(¬p)
Propiedades:

O(p ˄ q)<=> O(p) ˄ O(q) Distributiva

O(p) ˅ O(q) <=> O(p ˅ q) Asociativa

O(p) ˄ O(p=>q)=> O(q) Tautología deóntica

¬O(¬p) ˄O(p=>q)=> ¬O(¬q) Si está permitido p y p necesariamente implica q,

entonces está permitido q

O(¬q) ˄O(p=>q)=> O(¬p) Si está prohibido q y p necesariamente implica q,

entonces está prohibido p
 3.2.5.4. Lógica temporal

Es otra extensión de la lógica modal en donde se tiene en cuenta al tiempo.

En la lógica modal y proposicional, una proposición puede ser verdadera en un
momento determinado y puede ser falsa en el momento siguiente.
Veamos la siguiente proposición:
"está lloviendo" su valor de verdad depende del momento en el que se haga la
afirmación. Obviamente puede estar lloviendo y dejar de llover al momento siguiente.
En la lógica temporal, se agregan cuatro nuevos operadores monarios [22]:

G p será siempre verdad

H p siempre fue verdad

F p alguna vez será

verdad

P p alguna vez fue verdad

G y F son operadores débiles porque no sabemos si será verdad

H y P son operadores fuertes porque sabemos que ha sido verdad

Dentro de los pares fuertes (y de los débiles) los operadores son intercambiables.

Pp—>¬H¬p

Fp—>¬G¬p

Para poder determinar el valor de verdad de los operadores temporales, podemos

definir:
Pp es verdad en un determinado tiempo t 0, sí y sólo si p es verdad en algún tiempo
tal que t < t0
Fp es verdad en un determinado tiempo t0, sí y sólo si p es verdad en algún tiempo
tal que t0 < t
Hp es verdad en un determinado tiempo t 0, sí y sólo si p es verdad en todo tiempo tal
que t < t0
Gp es verdad en un determinado tiempo t 0, sí y sólo si p es verdad en todo tiempo tal
que t0 < t
Axiomas:

 Gp => Fp
 G(p => q) => Gp => Gq
 H(p => q) => Hp => Hq
 p => HFp
 p => GPp
 PPp => Pp
 FFp => Fp
 PFp => (Pp ˅ p ˅ Fp)
 FPp => (Pp ˅ p ˅ Fp)
 p => Lp para todo p que no contenga a F (es una necesidad histórica)
 (¬q ˄ Hq ˄ Lp) => GLH((¬q ˄ Hq) => p)

para profundizar, se recomienda la lectura de Luis Carlos Torres Soler – Inteligencia

Artificial: Conceptros básicos[22]

Hay varios sistemas lógicos basados en lógica temporal. Ver Lógica Computacional
[23]
:
 Lógica computacional en árbol (Computational tree logic – CTL): este modelo
es una estructura de tipo árbol donde se presentan caminos diferentes en
vista al futuro.
 Lógica temporal lineal (Linear-time temporal logic – LTL ): el tiempo se
modela como una secuencia finita de estados. Nos permite el concepto de
futuro. Fue analizada en 1977 por Amir Pnueli.
 Lógica temporal de intervalos (Interval temporal logic – ITL )

En el caso de LTL, se podrían agregar los siguientes operadores:

X Próximo estado

Fu Estado futuro

G Todos los estados futuros

U Hasta

R Lanzamiento
 3.2.5.5. Lógica Epistémica
Es otra extensión a la lógica modal que se ocupa del razonamiento sobre el
conocimiento[24][25].
El trabajo realizado por Georg Heinrik Von Wright (An essay in modal logic), en
1951, se considera el documento iniciador de la lógica epistémica.
El operador que agrega la lógica epistémica, se toma como K y significa “se sabe
que”
Por ejemplo, si expresáramos: Kaα se podría traducir como “El agente a tiene
conocimiento (o sabe) de α.
Por otro lado si anteponemos el operador negación (¬): ¬Kaα diríamos que “El
agente a no tiene conocimiento o no sabe de α”

Podemos analizar las siguientes propiedades:

 Kaα ˄ Ka (α=>β) => Ka β (propiedad de distribución)
 Ka α => Ka Ka α (propiedad de introspección positiva)
 ¬Ka α => Ka ¬Ka α (propiedad de introspección negativa)
 α = verdadero => Ka α es verdadero (propiedad de generalización del
conocimiento)
 Ka α = verdadero => α es verdadero (propiedad de la verdad)

3.2.5.6. Lógica Doxástica

La lógica doxástica es la extensión a la lógica modal que se ocupa de las creencias

[24][25]. Se define otro operador:
Bc α
Que se lee: el razonador c cree que α es verdadero.

Axiomas:
(Bc α ˄ Bc (α => β)) => Bc β
¬ Bc (α ˄ ¬α)
Bc α => Bc Bc α
¬ Bc α => Bc ¬Bc α
Kc α => Bc α
Para un buen resumen sobre los tipos de razonadores, puede verificarse el artículo
de wikipedia: Wikipedia-Lógica Doxástica

3.2.6. Arquitecturas deliberativas

Los agentes con éste tipo de arquitectura se caracterizan por contener una
representación simbólica del entorno y toman sus decisiones utilizando
razonamiento lógico o, al menos, pseudológico. Los agentes deliberativos, toman
decisiones teniendo en cuenta, esa representación simbólica y los datos obtenidos
de ese entorno (todo esto es su conocimiento) y modifican su estado interno en cada
decisión internalizando el nuevo conocimiento.
Son capaces de razonar sobre sus creencias e intenciones y armar una planificación
incluyéndolas.
Analizaremos algunas arquitecturas de agentes deliberativos:
 Agentes BDI
 Agentes planificadores
 IRMA
 GRATE
 PRS
 SOAR

En general las agentes con arquitecturas deliberativas tienen la siguiente estructura:

CC

Buscador Planificador
S
ACTUADORE

Intenciones

Deseos
Procesador Razonador
Creencias
SENSORES

Base de
conocimiento
 3.2.6.1. Arquitecturas BDI

Las aquitecturas BDI obtienen su nombre de Believe – Desires – Intentions

(Creencias – Deseos – Intenciones). Los agentes que implementan éste tipo de
arquitectura, pueden realizar tareas en ambientes dinámicos complejos. Para
comprendes los conceptos de creencias, deseos e intenciones, remitirse al punto
3.2.2

En 1995 Rao y Gerogeff desarrollaron un modelo para implementar éste tipo de

arquitectura .
La ventaja de éste modelo es su intuitividad. Es un modelo similar al modelo
psicológico que se aplica al cerebro humano.
La desventaja es que si se quiere que el agente posea tanto iniciativa como
reactividad, e muy difícil lograr un equilibrio entre ambas propiedades.
Generalmente responden a la siguiente lógica:

Begin
B=FB(p:P)
D=Opcion(B)
I=filtro(B,D,I)
return(ejecutar(I))
end

Veámoslo con un ejemplo; supongamos un sencillo termostato que debe mantener

una temperatura T en un ambiente.

D=mantener la temperatura en T
B={t(a), OK(T)}
I={Calentar, Enfriar, Nada}

P –> t(actual) –> A

Filtro: si A > T –> I=Enfriar

si A < T –> I=Calentar
 si A = T –> I=Nada

Acción: Case I
Enfriar Acción=Bajar la temperatura
Calentar Acción=Subir la temperatura
Nada Acción=Nada
En 1999 Wooldridge diseñó un flujo para un sistema BDI:

Ilustración 8 Flujo BDI

3.2.6.2. Agentes planificadores

La planificación busca determinar el conjunto de acciones a seguir de manera que
se apliquen a un conjunto discretos de datos para pasar por una serie de datos
buscando la solución a un problema meta.
Desde los comienzos de la inteligencia artificial, los agentes planificadores
resolvieron una miríada de problemas. Si bien se inicialmente se usaban sólo
algoritmos de búsqueda, se determinó que era mucho más eficiente el uso de
planificadores.
Mientras el plan se está ejecutando, el agente sigue recibiendo entradas verificando
si corresponde continuar con el plan o es conveniente ajustar el plan de acuerdo a
los nuevos datos sensados.
Si bien hay agentes que sólo son planificadores, en la ciencia de la computación, se
considera que todo agente inteligente debe tener un módulo planificador.
La idea del agente planificador es:
 Identificación del objetivo a alcanzar.
 Modelización e internalización del objetivo a alcanzar
 Determinación de las acciones que pueda realizar el agente.
 Representación del entorno
 Algoritmo para generar un plan (secuencia de acciones para lograr un
objetivo).
Mencionamos que un planificador es más eficiente que un sistema de búsqueda. De
manera que intentaremos determinar las diferencias:
 Los planificadores, al determinar el plan a seguir, mantiene un control sobre
todos los estados intermedios, mientras que los buscadores, sólo buscan la
mejor solución sin importar por los estados por los que pasa.
 Para determinar el plan de acción, los planificadores, no solo busca
determinar el paso por los estados intermedios, sino que también analiza los
efectos de las acciones a seguir determinando la estructura lógica del
problema.
 La mayoría de los planificadores, busca simplificar la complejidad del
problema generando subproblemas más sencillos de resolver y planificar

En los problemas de planificación clásica deben darse ciertas condiciones:

 Los problemas deben ser deterministas: los estados y las consecuencias de

las acciones deben estar perfectamente delimitados.
 Discretos: el entorno se considera discreto. Las acciones, los tiempos, los
estados y los efectos deben ser discretos o discretizables.
 Finitos: los estados y las acciones deben ser finitos.
 Estático: el entorno sólo cambia por acción del agente
 Información perfecta: el agente percibe todos los datos del entorno
concernientes a su operación y comprende perfectamente la respuesta de sus
acciones.
En el año 1998, los investigadores liderados por Drew MCDermott definieron el
PDDL (Planning Domain Description Languaje — Lenguaje de descripción de
dominio de planeamiento) que se diseñó como lenguaje para competición de
planificadores.
Actualmente, se considera como un estándar [26]. La versión 3.1 de éste estándar
salió en el 2011 y tiene varias extesiones y actualizaciones: PDDL+, NDDL, MAPL,
OPT, PPDDL y APPL entre otros.

Los componentes de PDDL:

 Objetos: los elementos del mundo que son afines al problema y al agente.
 Predicados: las propiedades binarias de esos objetos. (Verdadero o falso)
 Estado inicial
 Estado final (estado deseado o estado objetivo)
 Actuadores: acciones y operadores permitidos.
Cada PDDL se divide en dos archivos:
 Archivo de dominio (predicados y acciones)
(define (domain
<domain name>
)
<PDDL code for predicates>
<PDDL code for first action>
[...]
<PDDL code for last action>
)

 Archivo de problema (objetos, estado inicial y estado final)

(define (problem
<problem name>
)
(:domain
<domain name>
)
<PDDL code for objects>
<PDDL code for initial state>
<PDDL code for goal specification>
)

3.2.6.3. IRMA

IRMA es una sigla que significa Intelligent Resource-bounded Machine Architecture

(Arquitectura de máquina inteligente de recursos-limitados). Fue originariamente
diseñado por Bratman, Israel y Pollac, en el año 1998
IRMA tiene su origen en la arquitectura BDI pero con recursos computacionales
limitados.
Los investigadores centraron su atención en optimizar el proceso de filtrado que es
el que más recursos consume.

Tiene cuatro estructuras de datos simbólicos:

 Deseos: son los objetivos del agente.

 Creencias: son los datos que posee el agente.
 Librería de planes: contiene un conjunto de planes que tiene almacenado el
agente. Cada uno de los planes puede disparar procesos de razonamiento.
Establece la relación entre las condiciones y los planes.
 Intenciones como planes: contiene los planes de ejecución inmediata que se
consideran intenciones.

Y tiene cinco módulos de procesamiento:

 Analizador de oportunidades: selecciona planes de acuerdo a los ingresos
desde el medio del agente.
 Deliberador: produce las intenciones de acuerdo a las opciones y planes
sobrevivientes al filtrado
 Filtrador: Es el proceso que consume más procesador ya que es el encargado
de filtrar los planes y opciones propuestas eliminado las que pueden ser
contradictorias.
 Razonador: puede ser llamado por cada uno de los planes y su función es
proponer opciones. Planes parciales que puedan ayudar a cumplir los planes
llamadores. Pueden ser:
o Primario: razona sobre las creencias aceptándolas o rechazándolas.
o De medios y fines: coordina la operación interna del IRMA.
Este tipo de arquitectura se utiliza para agentes con recursos limitados ya que se
optimiza el Filtrador.

3.2.6.4. GRATE

La sigla GRATE significa Generic Rules and Agent model Testbed Environment
(Normas genéricas y Entorno de banco de pruebas de modelo de agente) y fue
propuesta por Jennings en 1993
La arquitectura ha sido diseñada en capas, en la cual el comportamiento del agente
está orientado por un estado interno controlado por BDI. Por diseño, el agente puede
tomar dos roles: individuo y miembro de un MAS.
Tiene tres modelos de información:
 Almacén de información: es el almacén de información de todo lo obtenido del
agente sobre sí mismo y sobre la interacción con otros agentes si los hubiera.
 Modelo interno: es el conocimiento del agente sobre sí mismo y sobre sus
estados internos.
 Modelo sobre el otro agente: contiene abstracciones de los agentes que
interactúan con el agente GRATE.

Y, por supuesto, tres módulos de procesamiento:

  Módulo de cooperación entre agentes (lógicamente contiene un módulo de
comunicaciones). Es el módulo de operar las actividades sociales del agente.
 Módulo evaluador de situaciones.
 Módulo controlador: responsable de las acciones del agente.
El nivel de dominio es un meta-nivel encargado de coordinación.

3.2.6.5. PRS

En el año 1980, Georgeff, Lansky e Ingrand entre otros, desarrollaron para el

Artificial Intelligence Center de SRI Internacional desarrollaron el concepto de PRS
que significa Procedural Reasoning System como marco de trabajo para desarrollar
sistemas de razonamiento que puedan moverse en entornos complejos en tiempo
real. Se basa en el modelo BDI.
PRS se desarrolló como un conjunto de áreas de conocimiento, cada una de las
cuales está concebida como un conjunto de procedimientos que establece cómo
debe realizar las acciones el agente.
Una aplicación muy interesante es el sistema de fallas del sistema de control de
reacción en el trasbordador espacial Columbia.
Su arquitectura es sencilla y puede verse en la siguiente figura:

Ilustración 9: Arquitectura PRS

Como puede verse en la ilustración, los componentes de PRS son los siguientes:
 Sensores: Es la comunicación del agente con el entorno.
  Creencias: Es la percepción y los conocimientos que tiene el agente del
entorno.
 Deseos: son los objetivos que debe alcanzar el agente.
 Razonador: es la máquina de inferencia que controla la operación del agente.
 Áreas de conocimiento-Planes: es la base con las secuencias de acciones a
bajo nivel que puede o debe realizar el agente.
 Intenciones: Son las secuencias de acciones que fueron seleccionadas por el
razonador para su ejecución inmediata.
 Actuadores: Son los elementos del agente que producen modificaciones en el
entorno. Las modificaciones pueden ser físicas o pueden ser información.

3.2.6.6. SOAR
SOAR es una arquitectura cognitiva que combina una arquitectura con un lenguaje
de programación[27].
SOAR fue creada por Laid, Newell y Rosenbloom en la Universidad Carneige
Mellon. Su desarrollo inició en 1983, pero oficialmente nació en 1987 con el paper
“Soar: An Architecture for General Intelligence”.
SOAR significa: State, Operator And Result (Estado, Operador y Resultado).
Y según la página puede ser cosas diferentes según la persona (temado de la
página: http://acs.ist.psu.edu/projects/soar-faq/soar-faq.html).
 Una teoría cognitiva: es el principio en el que se basa SOAR
 Un conjunto de principios y restricciones para procesamiento cognitivo
 Una implementación del punto anterior como un lenguaje de programación
 Un lenguaje de programación de Inteligencia artificial.
Entre otras cosas SOAR incorpora:
 Espacio de problemas como un marco de trabajo para todas las tareas y sub-
tareas para ser resueltas.
 Reglas de producción como representación del conocimiento permanente.
 Objetos con atributos y valores como una representación del conocimiento
temporario.
 Submetas automáticas como mecanismo simple para generar metas.
 Fragmentación como mecanismo simple de aprendizaje.

SOAR es una arquitectura basada en una teoría sobre lo que los comportamientos
cognitivos tienen en común[28].
 Ilustración 10 Arquitectura SOAR

Tiene las siguientes características:

 Es orientado a resultados
 Refleja un entono rico, complejo y detallado
 Necesita gran cantidad de conocimientos
 Requiere el uso de símbolos y abstracciones
 Es flexible en función del entono
 Requiere aprendizaje desde el entorno y la experiencia.
Esta arquitectura se desarrolló tomando como base los estudios sobre la solución de
problemas en seres humanos[28].
 3.2.7. Arquitecturas mixtas
Loa agentes reactivos y los lógicos deliberativos en estado puro, tienen ventajas y
desventajas[29]:
Arquitectura reactiva:
 Ventajas:
o La arquitectura reactiva posee. En especial si realiza directamente
como hardware
o Simplicidad de desarrollo tanto si se realiza por software o como
circuitos electrónicos.
o Al ser simples y sencillos son económicos.
o Por lo general son tolerantes a fallos
 Desventajas:
o No tienen representación interna del entorno solo tienen conocimiento
de lo que obtienen (u obtuvieron) con sus sensores.
o No planifican, sólo pueden reaccionar a lo que obtuvieron de sus
sensores
o Es dificultoso hacer que aprendan o que una vez entrenados, mejoren.
Arquitecturas lógico/deliberativas:
 Ventajas:
o Son de desarrollo elegante y metodológico
o Tienen una lógica clara (semántica clara)
o Aprenden y mejoran
 Desventajas:
o Son complejos de desarrollar
o Lentos para ejecución en tiempo real
o Mientras toma decisiones, se supone que el entorno no cambia.
o Toma las decisiones de manera racional

Los investigadores consideran que no es posible el desarrollo de un buen agente

utilizando las arquitecturas puras. Las arquitecturas mixtas o híbridas pueden
combinar lo mejor de cada una de las arquitecturas anteriores. La velocidad que
ofrecen las arquitecturas reactivas, con la adaptabilidad que ofrecen las
arquitecturas deliberativas y lógicas.
A fin de poder diseñar éste tipo de arquitecturas mixtas, se puede pensar como dos
subsistemas: uno reactivo que reaccione rápidamente a eventos disparados por el
entorno y uno lógico/deliberativo que le permita planificar o desarrollar
razonamientos lógicos en base a un conjunto de símbolos.
Hay dos posibles modelos en la implementación de estos dos subsistemas que se
presentarán como capas para la arquitectura míxta:
  Disposición horizontal: todas las capas del agente tienen acceso a los datos
que llegan del entorno por los sensores y todas tienen acceso a los efectores
que modificarán al entorno.
Podría considerarse a cada capa como un agente. Tiene como ventaja que se
puede tener una simplicidad conceptual ya que cada comportamiento
representa una capa. La desventaja es que puede darse una competencia
entre las capas, por lo tanto debe considerarse el uso de un mediador.
 Disposición vertical: Sólo una capa tiene acceso al entorno, sea sensores
como efectores. Generalmente esa capa es la capa reactiva. Tiene una
complejidad menor que la disposición anterior, pero eso le quita flexibilidad y
es menos tolerante a fallos.

3.2.7.1. TURING MACHINES

La arquitectura TuringMachine es una arquitectura de distribución horizontal de tres

capas, que se conectan todas al subsistema de sensores y al sistema de efectores.
Las tres capas que forman parte del subsistema de control:
 Capa de modelado
 Capa de planificación
 Capa reactiva
Las tres capas se comunican entre sí usando reglas de control específicas.

3.2.7.2. Arquitectura InteRRaP

InteRRaP[30] es una sigla que se corresponde a Integration of Reactive Behaviour

and Rational Planning. Está basada en la arquitectura RATMAN desarrollada por
Müller en 1991, que era exclusivamente deliberativa, con el agregado de
comportamiento reactivo. Es una arquitectura que separa las tareas control, del
conocimiento del agente.

Ilustración 11: Arquitectura InteRRaP

Es una arquitectura híbrida de capas verticales.

Como puede verse en el diagrama, tiene tres capas:
 Capa basada en conocimiento
 Capa de planeamiento local
 Capa de planeamiento social
Tiene un control de flujo de dos pasadas:
 Activación ascendente: cuando las capacidades de una capa son superadas o
excedidas, la capa superior toma el control.
 Compromiso descendente: las capas superiores usan las operaciones
primitivas de las capas inferiores para lograr sus objetivos

3.2.7.3. Guardian

Es un sistema adaptativo inteligente (Adaptative Intelligent System — AIS) [31]. Para

que un AIS sea efectivo debe ser capaz de percibir y actuar, lógicamente, y además
debe percibir, actuar, conocer y tener foco atencional. Hayes-Roth desarrolló
GUARDIAN como un sistema AIS. Fue desarrollado para monitoreo de pacientes de
terapia intensiva.
Comprende:
 Componente cognitivo (aplicando planificación de control dinámico, construye
y modifica planes de control incrementalmente)
 Un conjunto de canales de entrada/salida
  Un conjunto de subsistemas de entrada salida asincrónicos. Integra
percepción con cognición tanto como con los efectores del agente.
 Y un ciclo de razonamiento (implementado como un sistema de pizarrón en
paralelo)

Ilustración 12: Arquitectura GUARDIAN

Las ventajas de GUARDIAN según su diseño original son:

 Adquisición e interpretación de los datos del paciente de forma contínua.
 Construcción de planes de terapia a corto y largo plazo y monitoreo de la
ejecución de esos planes.
 Diagnóstico y alarma de desórdenes inesperados y complicaciones.
 Agilidad en la reacción a probblemas que requieren atención inmediata.
 Control de bucle cerrado de los dispositivos de terapia bajo demanda.
 4. De cómo los agentes se reúnen y forman sistemas
multi-agente

4.1. Introducción

Hasta ahora se han analizado los conceptos de los agentes. En éstas condiciones,
la programación de los agentes no se diferencia en nada de la programación de
módulos de inteligencia artificial. La verdadera potencia de éste paradigma es la
interacción entre los agentes, la potencia del procesamiento distribuido, la
especialización, puesta en común, etc.
Son muchas las formas de interacción entre los agentes, y se analizará inicialmente
los tipos de interacciones, para luego centrar el análisis en la comunicación entre
agentes.
Cuando los agentes interactúan, surge a priori, la necesidad de que se comuniquen
entre sí, de que reciban peticiones y resultados de otros agentes y de que puedan
comunicar sus propios resultados; de manera que surge la comunicación entre
agentes.
Al interactuar y comunicarse, al igual que en los grupos humanos (recordemos que
cuando definimos los agentes, vimos que los seres humanos cumplen con todas las
condiciones para ser agentes), los agentes forman estructuras sociales. Establecen
algún tipo de jerarquía organizándose, estableciendo arquitecturas de sistemas
multi-agentes.
En éste punto analizaremos las arquitecturas de sistemas multi-agente y las
comunicaciones entre los agentes siempre buscando responder a la pregunta ¿qué
se necesita tener en cuenta en la metodología?
El último punto que desarrollaremos es los lenguajes de programación que se
diseñaron específicamente para el desarrollo de agentes y multi-agentes.

4.2. Comunicación entre agentes

4.2.1. Introducción

La única manera de que los agentes interactúen entre ellos es que tengan algún tipo
de comunicación. El agente no puede cumplir con sus propios objetivos sin
considerar los de los otros. En algunos casos, un agente necesitará de la asistencia
de otros para llegar a sus metas; en otros casos, deberá competir con otros agentes
por el acceso a recursos y en otras oportunidades deberá negociar con sus
contrincantes porque sus objetivos pueden ser opuestos.
A la interacción entre los agentes se la denomina habilidad social. Esa habilidad
puede manifestarse a través de la cooperación, coordinación y negociación. La única
manera de interactuar sería usando algún lenguaje de comunicación.
En este punto se intentará responder a las preguntas: ¿Qué es comunicar? ¿qué
comunicar? y ¿cómo hacerlo?

4.2.2. ¿Qué es comunicar?

Como se ha hecho en otros puntos, nos remitiremos a la RAE para tener una
primera aproximación de lo que es comunicar.

Comunicar proviene del latín communicare y signigica:

1. Hacer a una persona partícipe de lo que se tiene
2. Descubrir, manifestar o hacer saber a alguien algo
3. Conversar, tratar con alguien de palabra o por escrito.
4. Transmitir señales mediante un código común al emisor y al receptor.
5. Establecer medios de acceso entre poblaciones o lugares.
6. Consultar con otros un asunto, tomando su parecer.
Como puede verse hay varias acepciones, y en el transcurso de éste punto, se verá
que pueden aplicarse todas ellas.

4.2.3. Formas de comunicación entre los agentes.

Son variadas las formas de comunicación entre los agentes. Casi siempre involucra
el intercambio de mensajes, pero no siempre.
Las formas de comunicación que se analizarán son las siguientes:
 Comunicación indirecta:
o Comunicación mediante el entorno.
o Sistema de pizarra
o Interacción sin comunicación (inferencias)
 Comunicación directa:
o Comunicación a nivel del conocimiento
 4.2.3.1. Comunicación mediante el entorno
Es un tipo de comunicación indirecta en dónde se dejan señales en el entorno para
que puedan ser analizadas y utilizadas por otros agentes.
Un tipo de comunicación mediante el entorno es el que sucede entre las hormigas.
Cuando una hormiga pasa por un lugar, va dejando un rastro de feromonas. Ese
rastro se va diluyendo con el tiempo. Pero cuando pasa la siguiente hormiga,
siguiendo el rastro, dejará también feromonas reforzando el rastro. Las hormigas son
un tipo de agentes (cumplen con todas las condiciones de agentes) y pueden
comunicarse entre sí sin estar uno con otro.

4.2.3.2. Comunicación mediante sistema de pizarra

La comunicación mediante un sistema de pizarra [32][33] es indirecta, porque no hay
comunicación directa entre los agentes. Toda comunicación se realiza mediante un
espacio (o varios) de memoria compartida a la que los agentes se registran y dejan o
toman mensajes del mismo.

La arquitectura de pizarrón es un medio de representación de conocimiento

accesible a todos los agentes. El primer programa que utilizó este método de
comunicación entre agentes ha sido un sistema de reconocimiento de voz llamado
Hearsay II.
Aspectos principales:
 Solución modular: Cada agente sólo puede ver el pizarrón y escribe en él si
ve algo de su incumbencia. Se pueden agregar o quitar agentes sin analizar
las interacciones entre ellos.
 Soluciones múltiples: En problemas complejos, muchos agentes especialistas
pueden hallar diferentes soluciones al mismo problema. En los casos de
múltiples soluciones, gana la solución hallada más velozmente.
 Depósito libre: El pizarrón es un depósito de información en los que los
agentes pueden almacenar, con la estructura adecuada, cualquier
información. Lógicamente no todos los agentes comprenderán toda la
 información que se almacene en el depósito, pero comprenderán la que
necesiten entender.
 Recupero de información: El almacén del pizarrón puede crecer mucho. El
pizarrón debe proveer los métodos para que el agente recupere la
información que le interese de manera rápida y precisa.
 Basado en eventos: Los agentes operan basados en eventos. Revisan el
pizarrón hasta que encuentran un evento que comprendan. Cuando son
activados, procesan y actualizan información en el pizarrón.
 Mecanismos de control: El pizarrón proveerá un mecanismo de control que
evite que los agentes accedan a la vez a la misma porción de información
para que no interfieran entre sí.
Los sistemas más modernos que implementan la estructura pizarra, pueden
incorporar uno o los dos siguientes agentes:
Agente moderador: Es un agente especializado que puede evaluar los elementos
que son publicados en la pizarra. Tiene capacidad de control y puede decidir a qué
agentes asignarle los problemas, de entre los que se registraron para resolverlos.
Agente despachador: Es un agente que verifica constantemente la pizarra y envía
mensajes a los agentes registrados cuando detecta algún cambio.
Por supuesto que, como cualquier tipo de arquitectura, tuene fortalezas y
debilidades.
La fortaleza principal es que para ésta arquitectura es sencillo agregar o quitar
agentes ya que sólo tienen que registrarse en la pizarra para hacer uso de ella lo
que lo hace independiente de la estrategia de cooperación que se establezca entre
los agentes. Es una arquitectura sencilla de implementar y no necesita que se
sincronicen las estructuras de datos.
La debilidad que presenta esta arquitectura es que la pizarra puede transformarse
en un cuello de botella. Es posible que se definan más de una pizarra, pero se le
agrega complejidad al sistema. Otro problema que presenta es el bloqueo de la tabla
mientras se escribe en ella. Con el uso de agentes moderadores y despachadores,
es posible evitar los bloqueos.

4.2.3.3. Interacción sin comunicación.

Ésta interacción completamente indirecta se realiza a través de la inferencia de
acciones de lo que realizan otros agentes.
Un ejemplo clásico es la utilización de la teoría de juegos para tratar de comprender
la interacción entre agentes competidores.
Un caso de aplicación de éste tipo de interacción es el famoso dilema del prisionero.
Se captura a dos delincuentes que cometieron un crimen. Se los encierra
incomunicados, y se le dice a cada uno: “Si uno de los dos confiesa, el delator
obtiene su libertad, mientras que el otro será condenado a cinco años; Si los dos
confiesan, purgarán dos años y medio; y si ninguno confiesa, irán sólo un año a
prisión”.
Si se analiza el dilema usando la teoría de juegos, se determina que la mejor opción
que tienen ambos delincuentes es mantener la boca cerrada. Pero no siempre
sucede.
En la robótica se aplica éste tipo re interacción en el sumo robótico y en los partidos
de football robótico.

4.2.3.4. Comunicación a nivel de conocimiento.

En éste tipo de comunicación directa, los agentes comparten conocimiento.
Comparten sus estados mentales, o persuaden e intentan modificar el estado mental
de otros agentes.
También transmiten necesidades y resoluciones obtenidas.
Hay varios estudios filosóficos sobre la comunicación entre los humanos y entre
otros seres racionales como los monos y los delfines. A lo largo de la segunda mitad
del siglo XX y principios del XXI, una corriente de investigación dentro de la filosofía
analítica, analizó los que se dio a llamar actos del habla o actos comunicativos.
Según lo analizado por Ana García Ferrante et. al. En su trabajo Comunicación entre
agentes[5], John L. Austin, Peter Strawson y John Serle analizaron profundamente los
actos del habla. De acuerdo con lo que dice Austin la enunciación es, por sí mismo
un acto, entendido como la transformación de las relaciones entre los interlocutores
o con los referentes.
De esta manera se pueden dividir los niveles del habla en tres:
 Acto locutivo: el acto de hablar en sí mismo.
 Acto ilocutivo: intención del emisor del mensaje.
 Acto perlocutivo: Son los efectos o consecuencias que causan los actos
ilocutivos.
Si analizamos los niveles, podemos ver que el acto locutivo puede coincidir con el
ilocutivo, lo que significa que hubo un acto directo de comunicación; y puede darse
que el acto locutivo no coincida con el ilocutivo, esto quiere decir que se realizó
usando un acto indirecto de comunicación.

Como se analizará en la sección lenguajes, FIPA se basa en éstas teorías para

desarrollar su lenguaje de comunicación entre agentes.
De acuerdo a lo expresado en el punto anterior, se agrupan las acciones en cuatro
tipos diferentes:

4.2.3.4.1. Tipo de información

Para éste tipo de actividad, hay dos agentes: el emisor y el receptor. Y el emisor
puede hacer una de dos acciones: ofrecer información o solicitar información.
 4.2.3.4.2. Tipo de realización de acciones
El agente puede tomar uno de los siguientes roles: el agente que está interesado en
que se realice la acción, el que solicita la acción; o el agente es el encargado de
realizar la acción.

4.2.3.4.3. Tipo de negociación

Los roles que pueden tomar un agente es: el agente está interesado en que se
realice una acción que no conoce las condiciones en las que el agente cooperante la
realizará; o el agente puede ser el agente cooperante que realizará la acción

4.2.3.4.4. Tipo de intermediación

El agente representará uno de dos roles: el que solicita la intermediación; o puede

ser el agente intermediario entre el agente emisor y todos los demás.

4.2.4. Pasaje directo de mensajes.

La comunicación entre los agentes, se realiza a través de mensajes, tanto en los
casos en donde hay comunicación directa, como en los casos en que la
comunicación es indirecta. Debe entenderse mensaje, como una estructura de datos
que se envía de una entidad a otra ya sea en forma directa o a través de una pizarra
o filesystem.

4.2.4.1. Estándares y protocolos de mensajes

Cuando se desarrolla un sistema multiagente, es posible diseñar una nueva
estructura y tipo de mensajes, pero no es aconsejable. Sería como reinventar la
rueda ya que hay varios estándares que pueden ser aplicados satisfactoriamente a
la mayoría de los casos.
Serán analizados los estándares:
 FIPA-ACL
 KQML
 KIF

4.2.4.2. FIPA-ACL
El FIPA-ACL es un estándar definido por Fundation for Intelligent Physical Agents
(FIPA – www.fipa.org) donde ACL significa Agent Communication Languaje.
Inicialmente analizaremos la composición de un mensaje FIPA-ACL.
Un mensaje se compone de la instrucción que indica el tipo de mensaje de que se
trata y de los parámetros del mismo. Los parámetros de los mensajes comienzan
con “:”

Parámetro Categoría y descripción.

performative Tipo de acto comunicativo. Son las operaciones que

puede realizar el agente. Más adelante se analizarán las
acciones posibles. Es un campo obligatrio.

:sender Participante de la comunicación. Es la identidad del

agente que envía el mensaje. Es un campo obligatorio.

:receiver Participante de la comunicación. Es la identidad del o de

los agentes destinatarios del mensaje. Sólo hay una
posibilidad de que éste campo se encuentre en blanco:
cuando se utilice algún tipo de proxy.

:replay-to Participante de la comunicación. Indica que los mensaje

subsecuentes deben ser direccionados al agente cuyo
identificador se pone en este campo. Es optativo.

:content Contenido. En este campo se envía el contenido del

mensaje. Lógicamente, el contenido debe ser
comprensible para el/los agente/s receptor/es.

:language Descripción del contenido. Determina el lenguaje en el

que el contenido se encuentra expresado.

:encoding Descripción del contenido. Es la codificación que se usa

en el contenido. Es un campo optativo ya que si no, se
toma la codificación por omisión.

:ontology Descripción del contenido. Tomando en cuenta la

ontología y el lenguaje, permite al agente receptor
interpretar el contenido del mensaje. Todos los
 mensajes FIPA comparten las siguientes ontologías:
fipa-acl-message y fipa-acl. En los casos que la
ontología sea común a todos los agentes, puede
omitirse este campo.

:protocol Control de conversación. Esto define el protocolo de

interacción para el mensaje. Si bien es un parámetro
opcional, se aconseja que se definan protocolos para la
mayoría de las acciones.

:conversation-id Control de conversación. Es un identificador único que

se utilizará durante toda la aplicación de los protocolos.

:reply-with Control de conversación. Este campo se utiliza para

poder seguir una conversación cuando se están dando
varias conversaciones simultáneamente.

:in-reply-to Control de conversación. Es una referencia al mensaje

previo que generó la necesidad de la respuesta.

Reply-by Control de conversación. Es un valor de fecha/hora que

pone límite a cuánto se va a esperar para recibir una
respuesta.

Tabla de propiedades del mensaje

4.2.4.2.1. Operaciones de los mensajes

Realización
Paso de Solicitud de Negociació Manejo de
Acto comunicativo de
información infromación n errores
acciones

accept-proposal ×

Agree ×

Cancel ×

Cpf ×

Failure ×

Inform ×

not-understood ×
 Propose ×

query-if ×

refuse ×

reject-proposal ×

Request ×

request-when ×

request-whenever ×

Subscribe ×

accept-proposal: el agente acepta la propuesta.

agree: el agente acepta la petición.
cancel: el agente cancela la petición que ha realizado.
cfp: el agente solicita propuestas para la realización de una acción (Call for
Proposals).
failure: el agente informa porque ha fallado en la acción.
inform: el agente envía información al agente requirente.
not-understood: el agente informa que no comprende el contenido del mensaje.
propose: el agente hace una propuesta. Generalmente como respuesta a un cfp.
query-if: el agente emisor consulta algo al agente receptor.
refuse: el agente rechaza un petición que le hizo otro agente.
reject-proposal: el agente rechaza una propuesta .
request: el agente solicita a otro que realice una acción.
request-when: el agente solicita a otro que realice una acción cuando se cumpla una
condición.
Request-whenever: el agente solicita a otro una acción que deberá hacerse siempre
que se cumpla con una condición.
subscribe: el agente se subscribe a un servicio de un agente receptor. El agente
receptor, cuando encuentre algo interesante para el elisor, se lo informará.

4.2.4.2.2. Protocolos definidos según las acciones

Se analizarán tres protocolos base:
  FIPA-Request
 FIPA-query
 FIPA-contract-net

4.2.4.2.2.1. Protocolo FIPA-Request

En éste protocolo, hay intervención de dos agentes. El Agente1 o agente solicitante,
solicita al Agente2 o agente ejecutor, que realice una acción.

En él diagrama de secuencias se tiene resumido todo el protocolo.

En la primera parte del diagrama, cuando el Agente1 hace el “request”, y el Agente2
responde “agree”, luego puede usceder una de las siguientes tres posibilidades: que
el Agente2 responda con un “inform” con “done” en el contenido (responde que ha
realizado la acción satisfactoriamente); que responda con un “done” con el resultado
en el contenido; o que haya fallado la operación o el cálculo y que devuelva “failure”
con el motivo del fallo en el contenido.

En la segunda parte del diagrama, ante el “request” del Agente1, el Agente2

responde un “refuse”, con lo cual rechaza hacer lo solicitado.

Y en la tercera parte del diagrama, ante el “request” del Agente1, el Agente2 no

comprende lo codificado en contenido y responde “nor-understood”.

4.2.4.2.2.2. Protocolo FIPA-Query

En éste protocolo, nuevamente hay intervención de dos agentes. El Agente1 o
agente solicitante, solicita al Agente2, que realice entregue información.

Cuando el Agente1 hace un “request” solicitando información al “Agente2”, este

puede responder según un de las 4 siguientes opciones:
 inform: el Agente2 envía la información requerida al Agente1.
 refuse: el Agente2 rechaza la solicitud hecha por el Agente1.
 failure: el Agente2 responde que hubo un error en la obtención de la
información requerida, y en el campo “content” consignará el motivo.
 not-understood: el Agente2 no comprende lo codificado en el campo “content”
 4.2.4.2.2.3. Protocolo FIPA-contract-net
En este protocolo, el Agente1 envía un mensaje “cpf” (call for proposals) solicitando
que uno o más agentes envíen propuestas para que realicen una acción. Es una
especie de encuesta o licitación en donde los agentes receptores propondrán
soluciones y luego, el Agente1 seleccionará una de ellas aceptándola (y rechazando
el resto si las hay).

En el diagrama de secuencias anterior, en el primer bloque, vemos el protocolo que

terminaría con una propuesta aprobada y respuesta por parte del Agente2.
El Agente1 envía un mensaje cfp al Agente2 (o a un grupo de agentes). El Agente2
comprende lo que necesita Agente1 y devuelve un “propose” con una propuesta de
resolución/acción. El Agente1 acepta la propuesta enviando un mensaje “acept-
proposal” a Agente2. Agente2 tiene tres posibles respuestas:
 inform: con la respuesta de la acción en el campo “content”
 failure: si algo falló, con la causa de la falla en el campo “content”
 cancel: si el Agente2 cancela la operación, enviará al Agente1 un mensaje
“cancel” y en el campo “content” enviará el motivo de la cancelación.
En el segundo bloque de la secuencia anterior, se analiza el caso en que la
propuesta se rechaza.
El Agente1 envía un mensaje cfp al Agente2 (o a un grupo de agentes). El Agente2
comprende lo que necesita Agente1 y devuelve un “propose” con una propuesta de
resolución/acción. El Agente1 acepta la propuesta enviando un mensaje “reject-
proposal” a Agente2.
En el tercer y último bloque de la secuencia, se analizan los casos en los que el o los
agentes receptores, no comprenden el mensaje o se niegan a hacerlo.
El Agente1 envía un mensaje cfp al Agente2 (o a un grupo de agentes). El Agente2
no comprende el contenido de “content” que envió Agente1 y devuelve un “not-
undertood”. Por otra parte si se niega, Agente2 envía un “refuse” con el motivo en
“content”.

4.2.4.3. KQML
KQML es la sigla para Knowledge Query and Manipulation Languaje (Lenguaje de
consulta y manipulación de conocimiento. El mismo ha sido desarrollado en el
programa ARPA Knowledge sharing effort (Esfuerzo de compartición de
conocimiento de ARPA).
KQML es tanto un formato de mensaje como un protocolo de manipulación de esos
mensajes. Se enfoca en un conjunto de enunciados performativos (son enunciados
que al utilizarse realiza la acción que significa). Que define las operaciones que los
agentes pueden intentar basado en los conocimientos de otros agentes y apuntando
a los objetivos. El desarrollo de este lenguaje se basa en la teoría de actos del
habla. Las oraciones expresadas por los humanos no siempre aseveran un hecho,
pueden transmitir una creencia, un conocimiento, una intención o un deseo. Además
puede establecerse una relación entre el estado interno de un agente y de los
mensajes que intercambia con los demás agentes. Como redes de contactos y
negociación entre agentes.

Características KQML:
 El lenguaje KQML cumple con los estándares FIPA (Foundation for Intelligent
Phisical Agents,).
  Los mensajes, además de tener una sintaxis y una semántica, comunican una
acción apoyada por el contenido (solicita, consulta, niega afirma, etc.)
 Las primitivas del lenguaje se llaman ejecutivas
o performativa
o acción
o realizativos
Estas primitivas señala las intenciones y las acciones de los agentes
influyendo en la base de conocimiento de los otros agentes.
 Es posible definir unos agentes especializados que se denominan agentes
facilitadores cuya función es coordinar la interacción entre otros agentes.
Realizando las siguientes acciones:
o Asociación de direcciones físicas con nombres simbólicos
o registro de bases de datos
o registro de servicios ofrecidos
o registro de servicios buscados por los agentes
o servicios de comunicación (reenvío, intermediación, etc.).

4.2.4.3.1. Capas del lenguaje KQML

El lenguaje KQML se encuentra estructurado en tres capas:

Capa de comunicaciones:
Establece la identidad de los agentes emisor y receptor, establece un identificador
único para la línea de comunicación.
Capa de mensaje
Es la parte central de éste lenguaje. Uno de los principales objetivos de ésta capa es
establecer el protocolo de transmisión del mensaje y establece el tipo de contenido:
comando, solicitud, pregunta, aserción, etc. Además, ya que el contenido es opaco a
KQML, en esta capa se incluyen características opcionales que describen el
contenido
Esta capa incluye las características de KQML: su lenguaje, la ontología que se usa
y alguna clase de descripción más general, analisis, enrutamiento y entrega del
mensaje.

Capa de contenido
Esta capa tiene el contenido real del mensaje. El lenguaje en el que está escrito este
contenido, está en un lenguaje que tanto el emisor como el receptor entienden.
Cualquiera de los agentes intermediarios puede que no entiendan el contenido del
mensaje. A esto se llama ontología compartida entre el emisor y el receptor. Es la
estructura de conocimiento que comparten el emisor y el receptor.

4.2.4.3.2. Sintaxis de KQML

Un mensaje KQML se inicia con una instrucción que se denomina ejecutiva. Esta
ejecutiva se ocupa de aclarar la intención del mensaje. Seguidamente viene la lista
de argumentos asociados (obligatorios) y los argumentos opcionales. El orden en
que aparezcan no es importante ya que tienen el formato “argumento”::= “valor”.
La sintaxis se basa en la filosofía del lenguaje LISP, trabajando con paréntesis.
La definición de la sintaxis es, utilizando la notación bakusnaur (BNF) donde [<x>]
significa que lo encerrado es opcional; <x>* significa cero o más; <x>+ significa uno
o más; y <x>|<y> es un OR exclusivo.

<performative>::=(<palabra>{<espacio>:<palabra><espacio ><expresión>}*)
<expresión>::=<palabra>|<cita>|<cadena>|(<palabra>{<espacio><expresión>}*)
<palabra>::=<carácter><caracter>*
<caracter>::=<abfabetico>|<numérico>|<especial>
<especial>::=<|>|+|-|*|/|&|~|^|_|@|%|$|:|.|!|?
<cita>::=’<expresión>|,<expresión con coma>
<expresión con coma>::=<palabra>|<cita>|<cadena>|,<expresión con coma>|
(<palabra> {<espacio><expresión>}*)
<cadena>::=”<caracter de cadena>*”|<dígito><dígito>*”ASCII”*
<caracter de cadena>::=\<ASCII>|<ASCII>-\-<comillas>

Los nombres de las performativas, son palabras claves del lenguaje. Y pueden
agruparse según su utilidad. No se analizará el contenido de cada una de las
performativas.

Ejemplo:
A envía a B
(ask-one
:content (interested ‘(sobre, bloquea, %x))
:language KIF
:ontology bloques
:reply-with q1)
B contesta a A
(reply
:content (sobre bloqueA bloqueF)
:language KIF
:ontology bloques
:in-reply-to q1)

4.2.4.3.3. Semántica de KQML

El modelo semántico de KQML es el encargado de definir un contexto para que los
agentes tengan conocimiento acerca de las capacidades de los otros agentes del
sistema.
Normalmente los agentes almacenan conocimiento en lo que se llama base de
conocimientos virtual (no siempre tiene un motor de base de datos) con dos tipos de
información:
 Creencias: es la base de conocimientos del agente, como también datos del
entorno y de otros agentes del SMA.
 Intenciones: son los objetivos del agente. Son los estados que el agente
quiere alcanzar.

4.3. Coordinación en sistemas multi-agente

4.3.1. Introducción

Como es posible imaginar, el trabajar con sistemas multi-agente, significa algún tipo
de coordinación de los sistemas multi-agente.
Pueden concebirse muchos agentes siguiendo un objetivo sin tener ningún tipo de
coordinación, mientras los objetivos sean simples. Pueden colaborar, lo que sin duda
requiere coordinación o pueden competir.

4.3.2. Tipos de relaciones entre los agentes

Podremos ver las relaciones entre agentes en el siguiente cuadro:

 Reducción de intervalos
Temporal
Extensión de intervalos
Recursos
Reducción de recursos
insuficientes
Competitivo
Material Sustitución de recursos
Tipo de
Cancelación de acciones
relación
Objetivos Incompatibles

Mismos objetivos Igualdad

Cooperativo Objetivos complementarios Favores

Refuerzo e inhibición Subsunción

En el caso de una relación competitiva, los agentes deben competir por algún
recurso escaso. Esa escasez no significa faltante. Es que, en un instante dado, lo
esté usando otro agente. Por ejemplo el acceso a un determinado efector o una
línea de comunicaciones en un instante dado.
Lo más interesante es cuando los agentes tienen objetivos incompatibles en donde
se dan negociaciones, intermediación, etc.

4.4. Lenguajes y herramientas de programación de agentes

4.4.1. Introducción

En la actualidad, hay muchos desarrollos de sistemas multi agente que utilizan

lenguajes de propósito general como C/C++, JAVA, PROLOG y otros. No hay nada
que impida el uso de éste tipo de lenguajes, pero se ha planteado la necesidad y
conveniencia de desarrollar y aplicar lenguajes específicos para la implementación
de agentes.

El uso de lenguajes dedicados, permite enfocarse en los aspectos importantes de la

programación de sistemas multi-agentes como los deseos, las comunicaciones, la
coordinación, etc.

Si bien hay muchos lenguajes que se han creado para trabajar con agentes (APL –
Agent Programming Languaje), no hay uno que se considere el principal, de manera
que en ésta sección se analizará el panorama de los lenguajes de programación de
agentes. Se hará incapié en los lenguajes más usados.

4.4.2. Lenguaje: 2APL/3APL

El lenguaje 3APL es uno de los lenguajes para definición de agentes más

desarrollados [34]. Está desarrollado en JAVA. Permite trabajar con arquitecturas BDI
(Ver punto 3.2.6.1 Arquitectura BDI). Es un lenguaje que se basa en especificar
programas que representen modelos mentales del agente.
Es un lenguaje intuitivo y simple. Se programan las creencias (a través de un
programa lógico) y las metas (que es un conjunto de átomos) que debe tener el
agente, y se establecen reglas de cómo construir los planes que unan esas creencia
con esas metas. El agente va pasando por diferentes estados que lo van acercando
a las metas. Esas reglas que se establecen son de semántica formal utilizando
transiciones. Cada estado tiene unas reglas locales y metas locales.

Ilustración 13: 3APL

La página web del proyecto es: http://www.cs.uu.nl/3apl/ En ella se pueden encontrar
las especificaciones, papers y software

4.4.2.1. Sintaxis

En la página web del proyecto se encuentra el archivo

(http://www.cs.uu.nl/3apl/bnf.pdf) en dónde se consigna la sintaxis del lenguaje.
<Program> ::= "Program" <ident>
( "Load" <ident> )?
"Capabilities :" ( <capabilities> )?
"BeliefBase :" ( <beliefs> )?
"GoalBase :" ( <goals> )?
"PlanBase :" ( <plans> )?
"PG−rules :" ( <p rules> )?
"PR−rules :" ( <r rules> )?

Como se ha explicado precedentemente, la definición de un programa es in conjunto

de capacidades, creencias, objetivos, planes y reglas.

A continuación la definición de cada uno de los conjuntos:

Las capacidades:
<capabilities> ::= <capability> ( "," <capability> )*
<capability> ::= "{" <query> "}" <Atom> "{" <literals> "}"

Las creencias:
<beliefs> ::= ( <belief> )*
<belief> ::= <ground atom> "." | <atom> ":−" <literals>"."

Los objetivos:
<goals> ::= <goal> ( "," <goal> )*
<goal> ::= <ground atom> ( "and" <ground atom> )*

Los planes:
<plans> ::= <plan> ( "," <plan> )*
<plan> ::= <basicaction> | <composedplan>
<basicaction> ::= "ε" | <Atom> | "Send("<iv>,<iv>,<atom>")" |
"Java("<ident>,<atom>,<var>")" | <wff>"?" | <atom>
<composedplan> ::= "if" <wff> "then" <plan> ( "else" <plan> )? | "while" <query> "do"
<plan> | <plan> ";" <plan>

Las reglas para los planes:

<p rules> ::= <p rule> ( "," <p rule> )*
<p rule> ::= <atom> "<−" <query> "|" <plan>
<p rule> ::= "<−" <query> "|" <plan>

Las reglas de revisión:

<r rules> ::= <r rule> ( "," <r rule> )*
<r rule> ::= <plan> "<−" <query> "|" <plan>

Los elementos básicos:

<literals> ::= <literal> ( "," <literal> )*
<literal> ::= <atom> | "not("<atom>")"
<wff> ::= <literal> | <wff> "and" <wff> | <wff> "or" <wff>
<query> ::= <wff> | "true"
<iv> ::= <ident> | <var>

4.4.2.2. El ciclo deliberativo

Ilustración 14: Ciclo de deliberación

 4.4.3. Plataforma: AF-APL

AF-APL significa Agent Factory - Agent Programming Languaje (Fábrica de agentes

– Lenguaje de programación de agentes)
AF-APL no es sólo un lenguaje de programación de agentes, sino que es un marco
de trabajo completo para el diseño y producción de agentes. Es un marco de trabajo
que brinda soporte estructurado para el desarrollo y despliegue de aplicaciones
orientadas a agentes.

Esta implementado en java cumpliendo con la norma J2SE y J2ME. El proyecto fue
abandonado hace 2 años. El código fuente puede bajarse de:
https://sourceforge.net/projects/agentfactory/

Está organizado en cuatro capas:

 Lenguaje de programación,
 Entorno de ejecución,
 Entorno de desarrollo y
 Metodología de ingeniería de software

4.4.3.1. Lenguaje de programación

Los programas AF-APL permite definir:

 Creencias
 Actuadores
 Perceptores
 Módulos
 Reglas de compromiso
 Objetivos
 Estado mental inicial

4.4.3.2. Entorno de desarrollo

El entorno de desarrollo está definido siguiendo los siguientes criterios:

 Distribuida
  Cumple con el estándar FIPA
 Tiene una plataforma de agentes y una infraestructura.
 Sistema de gerenciamiento de agentes

4.4.3.3. Entorno de ejecución

El entorno de ejecución está definido siguiendo los siguientes criterios:

 Compilador AF-APL
 Utiliza Netbeans y plugins Eclipse
 Tiene un editor de protocolos VIPER (VIsual Protocol EditoR)

4.4.3.4. Metodología de ingeniería de software

Si bien analizaremos más concretamente la metodología en el próximo capítulo,

podemos decir que la metodología se basa en tres pasos principales:
 Diseño: Con un proceso interactivo que abarca: Modelo de actividad, Modelo
de comportamiento del sistema y modelo de interacción. También deberá
diseñarse un modelo de Protocolo (usando VIPER) y, por supuesto un modelo
de agente.
 Implementación: Se basa en la definición de Ontologìas, construcción de
componentes de agentes, definición de los servicios de plataforma, Generar
las clases de agentes, Prueba de protocolos y Pruebas de comportamiento.
 Despliegue: Configuración de plataformas de agentes y despliegue de la
aplicación.

4.4.4. Plataforma: AgentBuilder

Agentbuilder es, según sus desarrolladores, es una suite de herramientas para

construir agentes software. La suite consiste en dos grandes componentes: el juego
de herramientas, y el sistema de ejecución que tiene la máquina de agente.

La página de ésta plataforma es www.agentbuilder.com y en ella se encuentra el

software, las especificaciones y varios papers.
Agent builder es compatible con cualquier versión de JAVA. Soporta KQML, CORBA
y se comunica a través de TCP/IP.
Es una plataforma comercial que brinda una versión de evaluación.
En la página web se explica que las herramientas contienen:
 Herramientas de control de proyecto: ayuda al desarrollador del agente
guiándolo a través de todo el proceso de desarrollo. Incluye el Gestor de
proyecto, la Herramienta de diccionario de proyecto y el Gestor de repositorio
de proyecto.
 Gestor de ontologías: asiste al desarrollador para el análisis del dominio del
problema y en la identificación de los conceptos relevantes a la operación del
agente en el dominio. Contiene las Herramientas para mapeo de conceptos,
Herramienta para graficado de conceptos y las Herramientas de modelado de
objetos.
 Gestor de agencia: Este gestor contiene las Herramientas de vista de agencia
y el editor de protocolos. El gestor permite construir una agencia. Una agencia
consiste en dos o más agentes que se comunican e interactúan para lograr un
objetivo. No importa si los agentes son iguales o especializados. El
desarrollador puede monitorear la interacción entre los agentes constitutivos.
 Gestor de agentes: Este gestor provee al desarrollador para desarrollar cada
uno de los agentes: su estado inicial, su comportamiento, sus creencias
iniciales, intenciones, capacidades y reglas de comportamiento.
 Depurador de agentes: es una herramienta que permite la comunicación con
un agente en ejecución para analizar su estado mental, mensajes de entrada
y de salida. Posee un visualizador de estado mental y un Editor KQML.

4.4.5. Arquitectura: Agent-K

Agent-K está desarrollado en prolog para el intérprete, y una librería externa (KAPI)
para la gestión y envío de mensaje.
Para Agent-K se emplea una gramática de clausula defnida, que parsea el mensaje
en búsqueda de tokens, y genera la lista. No se utiliza el set completo de mensajes
KQML, se ha definiso un conjunto reducido que permita convertir los mensajes en
prolog.
El predicado kqml_prolog(KQML, PROLOG) convierte kqml en prolog y viceversa.

La arquitectura de Agent-K consiste de cuatro componenetes:

 Creencias
 Compromisos
 Reglas de compromiso
 Acciones privadas

El Intérprete Agent-K genera el mensaje que se lo entrega al sistema de mensajes

Agent-K y forma el mensaje KQML. El mensake lo toma el parser KQML y usando la
API KAPI, genera el código Prolog y el código C necesario para comunicarse por
TCP/IP.
KAPI es una biblioteca de rutina C usada por enviar los menajes KQML via TCP/IP,
HTTP o correo electrónico.

4.4.6. Plataforma: AgentTool III

AgentTool [37] [38] es un proyecto del laboratorio de multiagentes y robots cooperativos

en la Universidad Estatal de Kansas.
El sitio web de AgentTool (http://agenttool.cs.ksu.edu/index.php) lo describe como
“un entorno de desarrollo gráfico basado en JAVA que ayuda a los desarrolladores a
analizar, diseñar e implementar sistemas multi-agente.”
AgentTool está preparado para seguir la metodología O-MaSE (Organizarion-based
Multi agent Systems Engineering) Ésta metodología se analizará en el capítulo 5.
Agent tool es un entorno de desarrollo gasado en JAVA. Está diseñado como una
serie de complementos (plug-ins) que se instalan en Eclipse (utilizando el menú de
complementos del mismo Eclipse).

Agenttool III tiene soporte para los siguientes modelos MaSE:

 Modelo de objetivos: es una estructura de los objetivos con propiedades, en
forma de árbol que tiene los conectores AND y OR.
 Modelo de objetivos basado en valores: es similar al anterior, pero sus
objetivos están basados en valores. El objetivo de basar en valores es
mantener los objetivos o el valor del sistema.
 Modelo de agentes: Define las clases de agentes y sus subclases que
formarán la organización. Incluye agentes, roles, organizaciones de agentes,
protocolos y servicios.
 Modelo de roles: Define los roles de los agentes que formarán la organización
para alinear a los agentes con los objetivos.
 Modelo de organización: Es un diagrama que muestra cómo interactúa la
organización con los elementos o actores externos al sistema.
 Modelo de protocolos: Es un diagrama de interacción realizado en AUML que
relaciona los roles, organizaciones y los actores externos a través del
intercambio de mensajes.
 Modelo de planes: Es un diagrama e estados que muestra una máquina de
estados finitos con estados y transiciones.
 Modelo de capacidades de acción: Es un diagrama que establece tres
niveles: capacidades, acciones y operaciones.
 Modelo de dominio: Es un diagrama que muestra el entorno en el que se ca a
mover el sistema multi-agente.
  Modelo de políticas: Es un documento que establece las políticas que se
aplicarán al sistema. Pueden ser obligatoria (leyes) u optativas (guías).
Utilizan una notación predefinida.
Agenttool III tiene además un módulo de generación de código y una herramienta
para establecer y controlar métricas.

4.4.7. Lenguaje: April

APRIL [39] es la sigla de Agent PRocess Interaction Languaje. Un lenguaje simbólico

orientado a procesos. Permite crear procesos y facilita la comunicación entre ellos.
Posee una estructura de datos robusta y muchas de las características que se
pueden encontrar en cualquier lenguaje de alto nivel. Permite el pasaje de funciones
y procedimientos entre los procesos.

Características específicas de April:

 Procesos nombrados públicos: Si bien el nombre de los procesos los asigna
April automáticamente, el programador puede darle nombres más
comprensibles como agente0, experto o buscador1. En caso de procesos
nombrados, los procesos son locales a la invocación de April excepto que
sean modificados como públicos registrándolo con el nombre del servidor al
cual está encadenada a la invocación de April.
 Comunicación entre procesos: La comunicación entre procesos es muy
sencilla. Los mensajes que pueden tener una estructura particularmente
compleja
 Entornos heterogéneos:
 Tiempo real:
 Características de orden superior:

4.4.8. Lenguaje: CAFnE

4.4.9. Lenguaje: CLAIM

 4.4.10. Lenguaje: ConGoLog

4.4.11. Lenguaje: COUGAAR

Cougaar es una arquitectura de agentes de código abierto. Su página principal es:

www.cougaar.org

4.4.12. Infraestructura: CYBELE

CybelePro es un desarrollo de Intelligent, Inc. Su ágina principal es: http://www.i-a-

i.com/cybelepro. La empresa lo describe como una suite de productos que ofrece
una infraestructura robusta de alta performance, servicios y herramientas para
desarrollo rápido y despliegue de sistemas distribuidos a gran escala.
La característica de ésta infraestructura es que la programación está centrada en la
actividad.
Cada actividad tiene seis estados:
 Ejecutable: es el estado inicial para todas las actividades. Queda a la espera
de eventos.
 Activo: la actividad se está ejecutando en su estado interno.
 En espera: la actividad está a la espera de que otra actividad termine.
 Evento bloqueado: el hilo se bloquea si la actividad envía un mensaje
sincrónico a otra actividad y espera por su respuesta.
 Actividad bloqueada: es cuando una actividad espera la finalización de otra
actividad hija finalice.
 Hecho: es cuando no espera más a ningún otro evento. Es una
autofinalización.
Hay cuatro relaciones de concurrencia entre actividades:
 Concurrente: es cuando dos actividades se ejecutan sin interferir una en la
otra.
 Evento serializado: si una actividad está activa, bloqueada por evento o
actividad bloqueada el cual pone a la otra actividad en espera. Esta relación
es conmutativa.
 Bloquea y espera: la primera actividad debe esperar a que la segunda
actividad finalice quedando en estado bloqueado.

Estados de transición entre las actividades:

 Ilustración 15: Transiciones Cybele

4.4.13. Lenguaje: DALI

4.4.14. Lenguaje: FIPA-OS

4.4.15. Lenguaje: FLUX

4.4.16. Lenguaje: FORR

4.4.17. Lenguaje: Goal

4.4.18. Lenguaje: GoLog

4.4.19. Lenguaje: IMPACT

4.4.20. Lenguaje: IndiColog

4.4.21. Lenguaje: Jack

4.4.22. Lenguaje: Jade

4.4.23. Plataforma: Jadex

4.4.24. Lenguaje: JAFMAX

4.4.25. Lenguaje: Jason

4.4.26. Lenguaje: KABUL

4.4.27. Lenguaje: MADKIT

4.4.28. Lenguaje: MDLP

4.4.29. Lenguaje: METATEM

4.4.30. Lenguaje: MINERVA

4.4.31. Lenguaje: NetLogo

4.4.32. Lenguaje: OAA

4.4.33. Lenguaje: Placa

4.4.34. Lenguaje: Procedural Reasoning System

 4.4.35. Lenguaje: Pups P3

4.4.36. Lenguaje: RETSINA

4.4.37. Lenguaje: ReSpecT

4.4.38. Lenguaje: SARL

SARL es un lenguaje de propósito general orientado a agentes. La página principal

de SARL es http://www.sarl.io.
Como se explica en la página, SARL provee abstracciones que permiten trabajar
con la concurrencia, distribución, interacción, descentralización, reactividad,
autonomía y reconfiguración dinámica.
Las herramientas SARL son Open Source bajo licencia Apache versión 2
permitiendo a los desarrolladores flexibilidad para trabajar con sus proyectos. Fueron
desarrolladas en JAVA de manera que el programador puede crear objetos y
llamarlo desde los agentes SARL de manera transparente.
La platafroma Janus provee un entorno de ejecución para los agentes SARL. Janus
en una plataforma multi-agente también de código abierto desarrollado
completamente en JAVA 1.7 que implementa toda la infraestructura requerida para
ejecutar un programa multi-agente desarrollado en lenguaje SARL.
SARL se basa en los siguientes conceptos:
 Agentes software emocionales: Cada agente es una entidad autónoma que
tiene capacidades de comportamientos programados que determinan su
conducta global. Un comportamiento mapea una colección de percepciones
(recibidas en la forma de eventos) con una secuencia de acciones. Los
eventos son elementos o situaciones en el medio que dispara, o no, el disparo
de efectos en el agente. Cuando se crea un agente, la máquina virtual
transfiere el control del programa emocional y habilita las capacidades
intrínsecas del agente.
 Capacidad y competencia: Una acción es un cambio en el estado interno del
agente o en el entorno del mismo. Este cambio intenta acercar al agente a
uno de sus objetivos. Una acción pasa de unas precondiciones a unas post-
 condiciones. Una capacidad es lo que un agente puede hacer, que
comportamientos requiere para su ejecución. Entonces una capacidad es una
especificación de una colección de acciones. Una competencia es una posible
implementación de una capacidad. Es posible que el agente adquiera nuevas
capacidades, esto genera nuevos comportamientos. Esto provee al agente
con mecanismos de adaptación que le permite cambiar su arquitectura de
acuerdo a necesidades y objetivos
 Contexto y espacio: el contexto define el entorno cercano del agente, y reúne
una colección de espacios. En cada contecto hay uno en particular que es el
espacio por omisión y es el que comparten todos los agentes. A su vez cada
agente puede crear su propio espacio público o privado para alcanzar sus
objetivos personales. Un espacio es el soporte de la interacción entre las
respectivas reglas definidas en la especificación de espacio. Por otra parte
una especificación de espacio define las reglas (acción-percepción) para
interactuar en un dado conjunto de espacios.
 Agentes recursivos o agentes software emocionales: Los agentes pueden
estar compuestos a su vez de agentes en un sistema multi-agente jerárquico.
Lo que hace que los agentes tengan un contecto interno y un contexto
externo.

4.4.39. Lenguaje: SOAR

4.4.40. Lenguaje: StarLogo

4.4.41. Plataforma: TuCSoN

4.4.42. Lenguaje: Viva

PARTE II: De las meto-
dologías de desarrollo
existentes de sistemas
multi-agente.
 5. Metodologías de desarrollo de sistemas multiagente

5.1. Introducción

5.1.1. Introducción

La palabra metodología proviene del griego μέθοδος que provinene a su vez de

μετά que significa más o meta, objetivo, οδως (odós) significa camino y λογος (logos)
significa estudio. Podemos decir que metodología es el camino, el conjunto de
procedimientos racionales que se utilizan para alcanzar el objetivo o la gama de
objetivos. Con frecuencia puede definirse la metodología como el estudio o elección
de un método pertinente o adecuadamente aplicable a determinados objetos.
La metodología supone sistematizar las series de procedimientos, la organización de
los pasos a través de los cuales se ejecutarán los procedimientos. No es posible
investigar sin pensar en la secuencia lógica de pasos que, necesariamente, deben
cumplirse para lograr cumplir con los objetivos de manera racional y segura.

5.2. Marco de análisis de metodologías agentes

5.2.1. Introducción
[35]

5.2.2. Metamodelos

5.2.3. Marco de análisis

5.3. Metodologías de desarrollo de sistemas multiagentes.

5.3.1. Introducción
5.3.2. Metodología: AAII/BDI

5.3.3. Metodología: AALADIN

5.3.4. Metodología: ANIC

5.3.5. Metodología: ARCHON

5.3.6. Metodología: Cassiopeia

5.3.7. Metodología: CommonKADS

5.3.8. Metodología: CoMoMAS

5.3.9. Metodología: DESIRE

5.3.10. Metodología: Gaia

5.3.11. Metodología: INGENIAS

5.3.12. Metodología: MADE

5.3.13. Metodología: MASB Method

5.3.14. Metodología: MaSE

5.3.15. Metodología: MASSIVE

5.3.16. Metodología: MESSAGE

5.3.17. Metodología: ODAC

5.3.18. Metodología: PASSI

5.3.19. Metodología: Prometheus

5.3.20. Metodología: RETSINA

5.3.21. Metodología: TROPOS

 5.3.22. Metodología: Vowels engineering

5.3.23. Metodología: ZEUS

5.4. Marco de comparación de Metodologías

Se han visto varias metodologías de desarrollo de sistemas multi-agente. Debemos

analizar un marco comparativo para poder seleccionar la metodología adecuada
para el desarrollo a realizarse. Muchos autores han analizado marcos de trabajo
para comparación de metodologías [35] y todos coinciden en que desarrollar un marco
que permita comparar metodologías es un trabajo complicado.
Durante los puntos anteriores hemos podido ver que las tecnologías de desarrollo de
sistemas multi-agente, tienen diferentes lenguajes, distinta estructura, asignan roles
y características de manera diferente
Componentes:
PARTE III: Implementa-
ción usando un sistema
multi-agentes.
 6. Metodología GAIA de desarrollo de sistemas
multiagentes.

6.1. Introducción

6.1.1. Propósito de la sección

El propósito de ésta sección es el de comprender la metodología GAIA para el

desarrollo de sistemas multi-agente (SMA) un poco más en profundidad para poder
desarrollar la IA para el juego siguiendo ésta metodología.

6.1.2. Alcances de la sección

El alcance de ésta sección del documento es servir de guía para la realización de

una Inteligencia artificial utilizando tecnología multi-agente para ser aplicada al
proyecto S.P.I.A.-Wari.
Es cierto que dentro de cada tipo de agente pueden utilizarse otras tecnologías de IA
que se introdujeron en alguna de las secciones del capítulo anterior; pero en ésta
sección nos abocaremos a la definición de una metodología que sirva en el
desarrollo del sistema multi-agente.
 7. Implementación
7.1. Introducción

En esta etapa implementamos el diseño en términos de componentes, archivos de

código fuente, scripts, ejecutables, etc. Describir las actividades que tendrá la fase
de Implementación. Trabajar de acuerdo a la metodología aplicada.

7.1.1. Propósito de la sección

El propósito de la presente sección es establecer las guias para componentes,

archivos de código fuente, etc.

7.1.2. Alcance de la sección

El alcance del presente documento es a los fines de presentar una guía de la

implementación del sistema.

7.2. Desarrollo de la IA para el juego SPIA-Wari

7.2.1. Introducción

8. Conclusiones
El desarrollo de un juego tiene ciertas complicaciones que sólo pueden
comprenderse desarrollando uno. Este proyecto me ha dado la oportunidad de
comprobar lo complejo del desafío de desarrollar un juego, además de ello permitir
que los jugadores puedan desarrollar la inteligencia artificial contra la cual competir
le agregó una complejidad extra.
 Referencias/Bibliografía

[1]
Michael Wooldridge: An introduction to multi-agent systems. John Willey & sons,
ISBN 0-471-49691-X. 2002
[2]
Doran Jim: Intervening to achieve co-operative ecosystem management: Towars
an agent based model. Journal of Artificial Societies and Social Simulation vol. 4, no.
2. 2001
http://jasss.soc.surrey.ac.uk/4/2/4.html

[3]
Michael Wooldridge: Agent-based software engineering. Proc on software
engineering. IEEE. 1997

[4]
JIMÉNEZ REY, M. Elizabeth; GROSSI, María Delia; PERICHINSKY, Gregorio:
Una Aplicación de la Tecnología de Multi-Agentes a los Sistemas Tutores
Inteligentes: Enseñanza de Computación en Carreras de Ingeniería

[5]
Ana Mas: Agentes software y sistemas multiagentes. Conceptos, arquitecturas y
aplicaciones. Pearson Educación S.A. 2005.

[6]
Rodney A. Brooks and Anita M. Flynn: Fast, cheap and out of control: A robot
invasion of the solar system. Journal of The British Interplanetary Society. Volumen
42. 1989; pp 478-485

[7]
Savage, John E.: Models of Computation, Exploring the power of computing.
Brown University; http://cs.brown.edu/~jes/book/. 2008

[8]
Freeman, James A.; Skapura, David M.: Redes Neuronales, Algoritmos,
aplicaciones y técnicas de programación. Addison-Wesley/Diaz de Santos. ISBN 0-
201-60115-X. 1991

[9]
J. J. Hopfield: Neural networks and physical systems with emergent collective
computational abilities. Proceedings of the National Academy of Sciences of the
USA. 1982

[10]
J. Febres, C. Prieto, Y. Gonzalez: Control en 2D de un asistente robótico para
cirugías laparoscópicas. Mecánica Computacional Vol XXIX. 2010; págs. 6539-6547
[11]
Felipetto

Xavier Basogain Olabe: Redes neuronales artificiales y sus aplicaciones.

[12]

Escuela Superior de Ingeniería de Bilbao. 2005

HAYKIN, Simón. Neural Networks, A comprehensive foundation, Second Edition.

[13]

Ed. Prentice Hall. ISBN 0-13-273350-1. 1999

[14]
http://www.swi-prolog.org/
[15]
http://www.learnprolognow.org/
[16]
http://homepages.inf.ed.ac.uk/stg/research/Psharp/
[17]
http://www.gprolog.org/
[18]
http://www.dobrev.com/
[19]
http://ciao-lang.org/
[20]
http://www.visual-prolog.com/

Zalta Edward: Basic Concepts in Modal Logic. Center for the Study of Languaje
[21]

and Information, Stanford University. 1990

Luis Carlos Torres Soler: Inteligencia Artificial: Conceptros básicos. Facultad de

[22]

ingeniería, Universidad Nacional de Colombia. 2007

[23]
José Luis Fernández Vindel, Ángeles Manjarrés Riesco, Francisco Javier Díez
Vegas: Lógica Computacional. Dpto. Inteligencia Artificial, E.T.S.I. Informática,
UNED — 2003

Manuel Sierra: Lógicas epistémica y doxástica con restricciones. Ingeniería y

[24]

ciencia; volumen 6 N° 12. 2010

Herrera Gonzalez, José Rafael: La lógica del conocimiento y la creencia.

[25]

Universidad de La Laguna, España. 2001

[26]
International Planning Competition. IPC2014. 2014.

[27]
Jill Fain Lehman, John Laird, Paul Rosenbloom: A Gentle Introduction to Soar, an
Architecture for Human Cognition. Sternberg & D. Scarborough (Eds). 1996
 Robert Wray y Randolph Jones: An Introduction to Soar as an Agent Architecture
[28]

– 2004

Robert Kowalski and Fariba Sadri: An Agent Architecture that Unifies Rationality
[29]

with Reactivity. Department of Computing, Imperial College, London. 1997

Jörg Müller y Markus Pischel: The agent architecture InteRRaP: Concept and
[30]

application. German Research Center for Artificial Intelligence (DFKI) – 2011

Ines A. Ferguson: TouringMachines: an architecture for dinamic, rational, mobile

[31]

agents. University of Cambridge Computer Laboratory. 1991

Max Winiewski: Agent-based Blackboard Architecture for a Higher-Order Theorem

[32]

Prover. Freie Universität, Berlin. 2014

[33]
D. Rudenko, A.Borisov: An overview of blackboard architecture application for real
tasks. Scientific proceedings or Rigal Technical University. 2007;

[34]
Gottifredi, Sebastián: Formalismos de argumentación en especificación de
agentes autónomos. Universidad Nacional del Sur. 2012

[35]
Arnon Sturm, Onn Shehory: A Framework for Evaluating Agent-Oriented
Methodologies. Lecture Notes in Computer Science Volume 3030. 2004. pp 94-109

http://link.springer.com/chapter/10.1007%2F978-3-540-25943-5_7#page-1

[36]
Winton H E Davies, Peter Edwards: Agent-K: An Integration of AOP and KQML
Department of Computing Science King's College University of Aberdeen

[37]
http://agenttool.cs.ksu.edu/
[38]
Juan C. Garca-Ojeda, Scott A. DeLoach, and Robby, agentTool III: From Process
Definition to Code Generation, - Proc. of 8th Int. Conf. on Autonomous Agents and
Multiagent Systems (AAMAS 2009), Decker, Sichman, Sierra, and Castelfranchi
(eds.), May, 10–15., 2009, Budapest, Hungary, pp. 1393-1394.
[39]
F.G. Mc Cabe, K.L.Clark: April - Agent PRocess Interaction Language, Dept. of
Computing Imperial College, London November 25, 1994
 9. Anexos
9.1. Códigos de transmisión.

A fin de poder minimizar los tiempos de transmisión entre equipos y simplificar el

envíos del string a las IA, se establece es siguiente código para las cantidades de
semillas por agujero y por almacén.

Códig Srin Semilla

o g s

64 @ 0

65 A 1

66 B 2

67 C 3

68 D 4

69 E 5

70 F 6

71 G 7

72 H 8

73 I 9

74 J 10

75 K 11

76 L 12

77 M 13

78 N 14

79 O 15

80 P 16

81 Q 17
82 R 18

83 S 19

84 T 20

85 U 21

86 V 22

87 W 23

88 X 24

89 Y 25

90 Z 26

91 [ 27

92 \ 28

93 ] 29

94 ^ 30

95 _ 31

96 ‘ 32

97 a 33

98 b 34

99 c 35

100 d 36

101 e 37

102 f 38

103 g 39

104 h 40

105 i 41

106 j 42
 107 k 43

108 l 44

109 m 45

110 n 46

111 o 47

De manera que cuando el sistema envíe a la IA o a la red la siguiente cadena de

caracteres:
“DDDDDDDDDDDD@@”
Estaremos diciendo que hay 4 semillas en cada uno de los agujeros y ninguna en
los almacenes. Ésta es la configuración inicial del juego.
La cadena:
“AEEEEDDD@EEE@@”
Estamos indicando que en el primer agujero hay sólo una semilla, en el segundo,
tercero, cuarto y quinto hay cinco semillas, en el sexto, séptimo y octavo hay cuatro
semillas, en el noveno no hay semillas, en el décimo, décimo primero y en el décimo
segundo, hay cinco semillas. No hay semillas en el almacén. Esta configuración
puede surgir cuando el primer jugador selecciona el primer agujero, y el segundo
jugador selecciona el noveno agujero.

NOTA: Por lo poco que es necesario transmitir se optó por la sencillez dado que
comprimir la información no tiene sentido.

Las IA deberán devolver un número del 1 al 6 seleccionando el agujero del cual

extraer las semillas.

NOTA: El sistema acondicionará el string para que siempre el valor devuelto sea un
número del 1 al 6.

9.2. Reglas del juego WARI.

El wari es el ajedrez de África. Pertenece a la familia del manqala, juego practicado

desde hace milenios, en sus distintas variantes, por la gente de África y oriente
medio. La variante que se suele llamar «wari», «ourri», «warri», «oware», «awari»,
«awele», o similares --que es la que comentaré aquí-- se juega en Costa de Marfil y
en el Caribe, lugar al que fue llevada por los esclavos negros.

9.2.1. Material
El material no puede ser más simple:
Cuarenta y ocho piedrecitas, semillas, palitos... cualquier cosa pequeña vale.
Doce (aunque, por comodidad, suelen ser catorce) recipientes o agujeros. Pueden
hacerse en el suelo, en un trozo de madera, en un bloque de arcilla...
Y dos personas dispuestas a exprimirse el cerebro

9.2.2. Objetivo
El objetivo del juego es hacernos con mas piedras, garbanzos, o lo que sean, que el
contrario. Puesto que hay cuarenta y ocho al empezar el juego, con capturar
veinticinco habremos ganado la mayoría de ellas y, por lo tanto, la partida.

9.2.3. Reglas
Las reglas del wari son sencillísimas:

9.2.4. Tablero
El tablero (si queremos llamarle así) está compuesto por dos filas de seis recipientes
o agujeros. De ellas, la que está más cerca de nosotros es nuestra, y la que está
más cerca de nuestro contrario suya. Siempre se empieza a mover desde un hoyo
de nuestro lado del tablero, y siempre se come en los hoyos del lado contrario.
Al empezar el juego en cada uno de los doce hoyos habrá cuatro fichas.
Además de estos, suele haber dos hoyos suplementarios, uno en cada extremo del
tablero, que se llaman «casas». El que queda a nuestra derecha es nuestra casa, el
otro la casa del contrario. Sirven para ir dejando en ellos las fichas que comamos
durante la partida.
Veamos cómo sería un tablero con casas al inicio de la partida

9.2.5. Movimiento
Un movimiento consiste en lo siguiente:
Tomamos todas las piedras de uno de los hoyos de nuestro lado.
Las vamos depositando una a una en los hoyos siguientes (tanto nuestros como de
nuestro rival) en el sentido contrario al de las agujas del reloj.
por ejemplo, si el jugador A mueve el hoyo de más a su derecha:
(se ha representado el movimiento de la mano del jugador A con una flecha)
Si el hoyo inicial contenía en concreto doce o más piedras, daremos una vuelta
completa al tablero; en ese caso el hoyo del que tomamos las piedras debe saltarse.
Es decir, al finalizar un movimiento, da igual el número de piedras que contuviera el
hoyo inicial, éste debe quedar siempre vacío.
Veamos un ejemplo. El jugador B mueve el hoyo que se indica.

9.2.6. Capturas
La captura, si se produce, es la última parte del movimiento:
Si al depositar la última piedra de un movimiento se hace en un hoyo enemigo, y
este contiene (contando la piedra que acabamos de depositar) dos o tres piedras,
estas son comidas. Es decir, las sacaremos y las dejaremos en nuestra casa (o las
mantendremos en la mano si jugamos en un tablero sin casas).
Lo mismo iremos haciendo, uno a uno, con los hoyos anteriores al último siempre
que contengan dos o tres piedras y pertenezcan al enemigo, hasta que lleguemos a
uno que no cumpla alguna de estas condiciones (del que no tomaremos las piedras).
Veamos un ejemplo:

El movimiento de la mano de A al retirar las fichas capturadas se representa en el

siguiente diagrama con una flecha gris:
El máximo número de piedras que podremos comer en un movimiento es pues de
dieciocho (tres en cada uno de los seis hoyos del rival).
Veamos una de las maneras de conseguirlo:

9.2.7. Reglas Suplementarias

Las dos reglas suplementarias conciernen al caso de que un jugador se quede con
todos los hoyos de su lado vacíos. Esto puede suceder por dos motivos:
Si un jugador realiza un movimiento y queda sin fichas en sus hoyos, el rival está
obligado a realizar en su turno un movimiento que introduzca fichas en el lado del
jugador que se ha quedado sin ellas.
Veamos un caso:

B ha quedado sin fichas, en su siguiente movimiento A debe darle fichas con que
seguir jugando. Sólo puede hacerlo moviendo del hoyo señalado.

En caso de que esto no sea posible la partida finaliza y el jugador que conserva
fichas en sus hoyos une estas a las que comiera durante la partida. Se considera
que controla el tablero y que, por tanto, todas las fichas que queden sobre él son
suyas.
Sin embargo, si un jugador realiza una captura y con ello deja al contrario sin fichas,
el contrario pasará en su turno y, siendo nuevamente el turno del que realizó la
captura, se aplica la regla anterior. Es decir, está obligado a introducir fichas en los
hoyos del adversario si le es posible. (el efecto es que el jugador que come todas las
fichas del lado del contrario, mueve de nuevo inmediatamente).
Veamos un caso:

B al comer ha dejado a A sin fichas, debe jugar inmediatamente y, aplicando la regla

anterior, debe mover del hoyo señalado, pues es el único movimiento que da fichas
a A.

9.2.8. Fin de la Partida

Cuando un jugador logra hacerse con la mayoría de las fichas (veinticinco o más), la
partida finaliza y ese jugador ha ganado.
Cuando un jugador logra controlar todas las fichas que quedan en el tablero como se
ha indicado más arriba, añade estas a las que haya comido y la partida finaliza. En
este caso ganará el jugador que haya conseguido el mayor número de fichas.
Veamos un ejemplo, le toca jugar a A (se observa que B está sin fichas y que A no
tiene ningún movimiento que se las dé, que son las dos condiciones para considerar
que A controla todas las fichas del tablero):
En ocasiones, cuando la partida está finalizando y quedan muy pocas fichas sobre el
tablero, se produce una posición que se repite cíclicamente sin que los jugadores
puedan o quieran evitarlo. En este caso la partida se considera finalizada y cada
jugador unirá a las que haya comido durante la partida las fichas que estén en su
lado del tablero.
Veamos una de tales posiciones:

Cuando ambos jugadores consiguen hacerse con veinticuatro fichas la partida

termina en empate.

9.2.9. Breves notas sobre técnica y estrategia

Una de las operaciones mentales más repetidas durante la partida de wari es
calcular en qué agujero acabará un determinado movimiento. Esto es importante al
momento de diseñar las inteligencias artificiales.
Hay un par de trucos que facilitan la vida:
El movimiento desde un agujero con seis fichas termina en el agujero que ocupa la
posición simétrica al de partida respecto al centro del tablero (el agujero final
siempre pertenecerá al rival, claro. A partir de esto, es fácil calcular dónde acabará
el movimiento de un hoyo con un número de fichas cercano a seis.
El movimiento desde un agujero con doce fichas termina en el agujero siguiente al
que contiene originalmente las fichas. A partir de esto, es fácil calcular también
donde acaban los movimientos de agujeros con algo más o menos de doce fichas.

En cuanto a la estrategia:
Acumular fichas: Una técnica básica es acumular cuantas más fichas mejor en uno
de los propios agujeros.
No dar fichas al rival: Una segunda técnica básica consiste en tratar de que los
propios movimientos no metan fichas en los agujeros del rival, sino que sean
movimientos cortos completamente dentro de los hoyos propios.