Agente dirigido mediante tabla¶

Un agente dirigido mediante tabla es un agente que ejecuta la función del agente a partir de una tabla de percepciones y acciones, la cual, precisamente, asocia a cada secuencia de percepciones una acción.

Antes de definir este agente determinaremos el ambiente, que en este caso será el mundo de la aspiradora, pues este mundo permite definir una tabla que puede llegar a solucionar el problema de limpiar del mundo, aunque no de la manera más eficiente.

In [1]:
from vacuum_world import VacuumWorld

env = VacuumWorld()
print(env)

[(A,1) (B,0)]
[(C,0) (D,1)]

Generación del agente dirigido mediante tabla¶

El agente guardara las percepciones, así como las locaciones. El agente requiere de una tabla para poder ejecutar las acciones. En este caso, la tabla que definiremos tomará sólo una percepción, pero pueden definirse agentes dirigidos mediante tablas que puedan tomar una secuencia de percepciones más extensa.

Definimos una función decide que determina una acción en base a la tabla de percepciones. Dada la percepción actual, se accede a la acción que la tabla asocia. Asimismo, puede ejecutar la acción.

In [2]:
import random
random.seed(12345)

class TableDrivenAgent(VacuumWorld):
    """
    Objeto agente.
    """
    def __init__(self, table, location=None):
        """
        percept
            Percepción del agente, enlista las percepciones hasta el estado actual
        table
            Tabla de percepción-acción
        location
            Lugar donde se localiza el agente
        """
        self.location = location
        self.perceptions = [(self.location.name, self.location.dirt)]
        self.table = table
        
    def decide(self):
        """
        Simple función para ejecutar una acción a partir de 
        consultar la tabla
        """
        action = self.table[self.perceptions[-1]]
        #Cuando se tiene más de una acción
        #la acción se realiza aleatoriamente
        if type(action) == list:
            action = random.choice(action)
        
        return action
    
    def act(self,action):
        """Función para actuar"""
        if action == 'Clean':
            self.location.dirt = 0
            self.perceptions.append((self.location.name,self.location.dirt))
        elif action == 'Left':
            self.location = self.location.left
            self.perceptions.append((self.location.name,self.location.dirt))
        elif action == 'Right':
            self.location = self.location.right
            self.perceptions.append((self.location.name,self.location.dirt))
        elif action == 'Up':
            self.location = self.location.up
            self.perceptions.append((self.location.name,self.location.dirt))
        elif action == 'Down':
            self.location = self.location.down
            self.perceptions.append((self.location.name,self.location.dirt))
        else:
            print('No es una acción permitida')

La tabla que definimos es muy simple, toma únicamente la percepción, el lugar en el que se encuentra el agente y si este esta sucio o limpio. Si está sucio, limpia el cuarto, pero si está limpio, entonces se mueve hacia un cuarto cercano. Esta tabla no es la única posible y puede ampliarse si se considera un número mayor de percepciones.

In [3]:
#tabla de percepciones
table = {('A',1):'Clean', ('A',0): 'Right', 
         ('B',1):'Clean', ('B',0): 'Down',
         ('C',1):'Clean', ('C',0): 'Right', 
         ('D',1):'Clean', ('D',0): 'Left'}

Ahora podemos definir al agente, posicionándolo en el primer cuarto y viendo cuál es la última percepción que se ha definido.

In [4]:
agent = TableDrivenAgent(table=table, location=env.A)
print(agent.perceptions)

[('A', 1)]

Finalmente, podemos usar las percepciones para que el agente escoja una acción con respecto a la tabla y la última percepción que tuvo. De esta forma modifica el ambiente buscando limpiar todos los cuartos.

In [5]:
action = agent.decide()
agent.act(action=action)
print('Ambiente después de la acción {}:\n{} {}'.format(action,env,agent.location))

action = agent.decide()
agent.act(action=action)
print('Ambiente después de la acción {}:\n{} {}'.format(action,env,agent.location))

action = agent.decide()
agent.act(action=action)
print('Ambiente después de la acción {}:\n{} {}'.format(action,env,agent.location))

action = agent.decide()
agent.act(action=action)
print('Ambiente después de la acción {}:\n{} {}'.format(action,env,agent.location))

action = agent.decide()
agent.act(action=action)
print('Ambiente después de la acción {}:\n{} {}'.format(action,env,agent.location))

Ambiente después de la acción Clean:
[(A,0) (B,0)]
[(C,0) (D,1)] A
Ambiente después de la acción Right:
[(A,0) (B,0)]
[(C,0) (D,1)] B
Ambiente después de la acción Down:
[(A,0) (B,0)]
[(C,0) (D,1)] D
Ambiente después de la acción Clean:
[(A,0) (B,0)]
[(C,0) (D,0)] D
Ambiente después de la acción Left:
[(A,0) (B,0)]
[(C,0) (D,0)] C

El problema de este agente es que la tabla puede ser difícil de construir, pues hay más de una acción que se puede realizar en cada estado. Asimismo, tener un agente dirigido mediante tabla implica que quien programa conozca un plan para que el agente pueda completar su tarea, si este plan no se conoce, no se puede garantizar que el agente cumpla con el objetivo. Asimismo, este plan puede ser poco eficiente, en este ejemplo, la tabla completa la tarea, pero siempre en el mayor número de pasos.