Memoria de agentes reactivos para la clase de LSIN

1. PRÁCTICA 3 - LSIN
Programación de Agentes Reactivos
Daniel Sánchez Seijo
daniel.sseijo@alumnos.upm.es

2. Práctica LSIN – Agentes Reactivos
Daniel Sánchez Seijo 1
Contenido
Introducción.................................................................................................................................. 1
Decisiones y posibles soluciones................................................................................................... 1
Programación................................................................................................................................ 2
Avanzar, MediaVuelta, GirarIzquierda y GirarDerecha............................................................. 2
IzquierdaFrente y DerechaFrente ............................................................................................. 3
Bifurcación y Cruce.................................................................................................................... 4
Pruebas y conclusiones ................................................................................................................. 5
Introducción
En esta tercera entrega, se nos propuso realizar la arquitectura de un robot para que
este consiguiese salir de un laberinto cualquiera. Estos robots se comportan como agentes
reactivos. Un agente reactivo debe actuar según las condiciones que se den en ese momento en
el entorno sin poseer ningún tipo de información adicional.
Para realizar esta práctica se utilizó el software adaptado de los robots producidos por
LEGO denominados LEGO Mindstorm para crear una arquitectura de subsunción que permitiese
anidar acciones para que el robot consiguiese salir del laberinto.
El lenguaje utilizado en la práctica es leJOS, un lenguaje basado en Java que nos permite
implementar una clase con varios métodos que nos ayudará a la hora de entender el
comportamiento de nuestro robot.
En la práctica se nos proporcionan cuatro laberintos distintos, ahora veremos el
procedimiento seguido para conseguir resolver estos laberintos.
Decisiones y posibles soluciones
Para la realización de la práctica he decidido usar la opción de Eclipse para programar,
por lo tanto la instalación resultó rápida y sencilla una vez importé el paquete de Java3D para el
simulador. Las primeras ejecuciones del robot me hicieron percatarme de que el simulador no
siempre ejecuta el algoritmo en el mismo momento, por tanto hay veces que el robot gira
demasiado pronto o demasiado tarde o ni siquiera llega a ejecutar la acción que debería y pasa
de largo en el laberinto.
Por tanto, una de la primeras acciones que hice tras consultar la documentación del
robot fue la de cambiar el método forward() que se ejecuta para seguir de frente por el método
travel(float distance). Este método permite mover al robot una cierta distancia, por lo tanto,
calculé la distancia que supone avanzar una casilla del laberinto al robot y usé este método para
que el robot esperase a tomar la siguiente decisión y no producir cambios entre ejecuciones.
A la hora de programar la manera de moverse del robot, elegí implementar todas las
opciones que nos puede ofrecer un laberinto, y como el robot no guarda registro de lo que ha
andado previamente, las decisiones que toma en intersecciones es aleatoria, es decir, cada vez
que se ejecuta puede realizar un camino distinto pero terminará saliendo del laberinto
finalmente.

3. Práctica LSIN – Agentes Reactivos
Daniel Sánchez Seijo 2
Antes de programar esta opción, quise
implementar la llamada solución de la mano
izquierda, la premisa de esta solución consiste en
que si el robot siempre mantiene la pared izquierda
(o siempre la derecha) pegada a él, al final
conseguirá salir del circuito, pero el problema es
que esta solución no resuelve todo tipo de
laberintos, los cuatro proporcionados si se
lograrían resolver, pero si por ejemplo en el
laberinto número 2, el robot comienza en la posición indicada en la Ilustración 1, éste no saldría
de la pequeña isla y se mantendría girando perpetuamente alrededor de ella sin resolver nunca
el laberinto. Para solucionar este problema elegí por tanto la resolución mediante decisiones
aleatorias.
Programación
Una vez estudiados los posibles estados por los que pasa el robot en el laberinto me
dispuse a programarlos. A continuación se explican las características añadidas a cada una de
las clases para lograr que el robot se comporte correctamente hasta la salida de los laberintos.
Avanzar, MediaVuelta, GirarIzquierda y GirarDerecha
En primer lugar, implementé las clases que no suponían ningún tipo de decisión más allá
que la que obtienen de los sensores. Avanzar continúa siendo, al igual que en el ejemplo, la clase
base del arbitrator, el único cambio apreciable es la sustitución del método forward() por el
método travel(float distance) como indicamos anteriormente. Los métodos takeControl y
suppress no varían en esta clase.
Para implementar MediaVuelta, se añadieron más restricciones para que esta clase
tomase el control, en esta ocasión, aparte de no poder continuar de frente, el robot tampoco
puede tener la opción de girar a izquierda ni a derecha, este límite por los laterales se limita con
una nueva variable añadida al dataExchange denominada maxLatDistance.
Cuando se cumplen estas tres opciones, significa que el robot se encuentra en un
callejón sin salida, y por tanto, no tiene más remedio que dar completamente la vuelta.
Ilustración 1

4. Práctica LSIN – Agentes Reactivos
Daniel Sánchez Seijo 3
GirarIzquierda y GirarDerecha son completamente idénticos el uno al otro, cada uno
con su giro correspondiente. En este caso, tomará el control cuando sea imposible girar en la
dirección del método únicamente. Por ejemplo, la siguiente ilustración muestra el giro a la
izquierda y el código mediante el cual toma el control.
En el método action() de todos los movimientos con giro se incluye, justo después, el
avance a la posterior casilla en la cual ya se volverán a leer sensores. De este modo, el robot no
se queda girando sobre sí mismo en ciertos casos.
IzquierdaFrente y DerechaFrente
Entramos en los casos en el que tenemos más de una posibilidad de elegir el camino. En
estos dos casos encontramos la opción de girar a la izquierda o derecha a través de un hueco o
seguir de frente directamente.

5. Práctica LSIN – Agentes Reactivos
Daniel Sánchez Seijo 4
Para implementar estos casos así como el resto de casos que se expondrán a
continuación, creé una nueva variable en el DataExchange. Esta variable devuelve un booleano
aleatorio que se usará para la decisión. Por tanto, cuando nos encontremos en una situación en
la que no tengamos nada por el frente pero tampoco por uno de los extremos, el robot elegirá
aleatoriamente el camino a seguir.
Con estos dos métodos solucionamos los casos en los que tenemos una salida a la
derecha o izquierda pero no sería obligatorio el giro a dicha salida si no que se podría optar por
seguir de frente.
Bifurcación y Cruce
En estos dos casos tenemos las últimas opciones que se pueden dar en un laberinto, en
primer lugar, estudiamos la bifurcación como la opción del robot de elegir un camino a la
derecha o un camino a la izquierda. Para que esta acción se lleve a cabo, el robot comprobará
que sus dos laterales están libres y su sensor frontal encuentra una pared y no podrá avanzar.
De nuevo, hacemos uso de la variable aleatoria booleana para elegir el camino a seguir.
Como vemos, estos métodos son todos bastante similares cambiando sensores para
tomar el control y cambiando las acciones dependiendo del giro elegido.
Por último, tenemos el cruce, el caso más completo en el que el robot tendrá tres
posibles opciones: seguir de frente, girar a izquierda y girar a derecha.

6. Práctica LSIN – Agentes Reactivos
Daniel Sánchez Seijo 5
Para llevar a cabo esta última elección, pediremos dos booleanos en lugar de uno al
DataExchange, de este modo elegiremos primero entre continuar de frente o rotar a la izquierda
y por último rotar a la derecha.
Con este último método, tenemos cubiertos todos los posibles problemas que pueden
planteársele al robot al resolver el circuito.
Pruebas y conclusiones
A la hora de probar el robot, es muy útil tanto el simulador proporcionado como los
distintos laberintos que ponen a prueba al robot para completar las tareas. Las pruebas se han
realizado a base de diseñar nuevas capas en la arquitectura de subsunción del robot para
superar los problemas que fueron apareciendo a lo largo de la resolución de los circuitos.

7. Práctica LSIN – Agentes Reactivos
Daniel Sánchez Seijo 6
Como ya se comentó al principio, la estrategia de la mano izquierda se desechó en
seguida al no poder resolver todos los circuitos, con esta nueva estrategia el robot consigue
hacer buenos tiempos, a pesar de la aleatoriedad de sus decisiones que pueden tenerlo largo
rato dando vueltas en un mismo punto.
Este es un problema de los agentes reactivos, precisamente que no se pueda recordar
nada del recorrido, ya que esto permitiría corregir trayectorias y eliminar posibilidades para que
el robot resolviese mucho más rápido el circuito. Aun así, los agentes reactivos nos permiten
aprender la arquitectura básica de un robot y esta práctica nos ayuda en la compresión y el
estudio de los mismos.
Como conclusión a las pruebas al robot, en el simulador, se han conseguido resolver, en
tiempos relativamente cortos, los cuatro circuitos disponibles con la opción de realismo
desactivada y también con ella activa aunque, como era de esperar, con más dificultades.