Agente reactivo simple

Un agente reactivo simple es un agente que reacciona sólo a la percepción actual; en este sentido, no requiere de la historia de las percepciones para solucionar un problema. Este tipo de agentes no requieren guardar percepciones, ya que simplemente actúan ante la percepción actual.

Aquí proponemos un agente reactivo simple para el mundo de la aspiradora. En primer lugar, creamos el entorno:

from vacuum_world import VacuumWorld

env = VacuumWorld()
print(env)

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

Creación del agente

Un agente reactivo simple no requiere guardar una secuencia de percepciones, pues selecciona una acción en base únicamente a la percepción actual del mundo. De cierta forma, este agente no preserva memoria de las percepciones pasadas.

El agente reactivo simple se basará en reglas de condición-acción, las cuáles son reglas que seleccionan una acción en base a una condición; estas reglas son de la forma ''si $X$ entonces $Y$''. El programa del agente puede pensarse como:

procedure Simple-Reflex-Agent(percept) {
  persistent: rules, Reglas condición-acción;
  state = Interpret(percept)
  action = Rule_match(state, rules)
  return action
}

En este caso tendremos reglas de la forma

if percept == X:
    action = Y

Es decir, la coincidencia de la regla con el estado se da en las condiciones. Para el mundo de la aspiradora, considerando que las percepciones se interpretan como estar sucio y la localización del agente, tendremos las siguientes condiciones:

if is_dirt == True{
    action = Clean
}
else{
    if agent_location == A:
        action = Right
    if agent_location == B:
        action = Down
    if agent_location == C:
        action = Up
    if agent_location == D:
        action = Left
}

Estas reglas bastarán para que el agente actúe en el mundo.

class SimpleReflexAgent(object):
    """ Agente reactivo simple."""
    def __init__(self, location=None):
        self.location = location
        #No guarda historia de percepciones
        
    def decide(self):
        """Función de decisión basada en la percepción actual"""
        if self.location.dirt == 1:
            self.location.dirt = 0
            return 'Clean'
        else:
            if self.location.name == 'A':
                self.location = self.location.right
                return 'Move to {}'.format(self.location.name)
            elif self.location.name == 'B':
                self.location = self.location.down
                return 'Move to {}'.format(self.location.name)
            elif self.location.name == 'C':
                self.location = self.location.up
                return 'Move to {}'.format(self.location.name)
            elif self.location.name == 'D':
                self.location = self.location.left
                return 'Move to {}'.format(self.location.name)

Ahora podemos pasar a aplicar las reglas de condición-acción del agente reactivo simple en el mundo de la aspiradora. Iniciamos el agente en una posición.

agent = SimpleReflexAgent(location=env.A)
print(env)
print(agent.location)

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

Ahora podemos hacer que el agente reactivo simple actúe hasta que logre limpiar todo el ambiente.

#Mientras haya suciedad en un cuarto
#el agente ejecutará las reglas de condición-acción
while not all([sq.dirt==0 for sq in env.squares]):
    print(agent.decide())
    print(agent.location)
    print(env)

Clean
A
[(A,0) (B,1)]
[(C,1) (D,0)]
Move to B
B
[(A,0) (B,1)]
[(C,1) (D,0)]
Clean
B
[(A,0) (B,0)]
[(C,1) (D,0)]
Move to D
D
[(A,0) (B,0)]
[(C,1) (D,0)]
Move to C
C
[(A,0) (B,0)]
[(C,1) (D,0)]
Clean
C
[(A,0) (B,0)]
[(C,0) (D,0)]

En general, este agente reactivo simple será capaz de cumplir con el objetivo de limpiar el cuarto sin importar la configuración en el que este cuarto se encuentre, ni la posición en que el agente comience. Pues, sin importar su posición inicial, el agente recorrerá todo el ambiente en el sentido de las manecillas del reloj. Si inicia en A, pasará a B, después D y finalmente C; pero si inicia en C, pasará a A, luego a B y finalmente a D.

Además, el agente revisa primero si la percepción le dice que el cuadro está sucio, y si es el caso, lo limpia. Si no, se moverá como lo hemos indicado. De esta forma garantizamos que limpia antes de moverse y, por tanto, que al recorrer todos los cuartos acabará por limpiarlos.

Sin embargo, este agente no optimiza el tiempo en que tarda en limpiar los cuartos, pues si, por ejemplo, si el agente inicia en A y sólo está sucio el cuarto C, el agente recorrerá todos los otros cuartos antes de completar la tarea, en lugar de moverse directamente de A a C.

Esto se complejiza cuando el ambiente cuenta con más cuartos. En mundos muy grandes, con un gran número de cuartos, el agente tendrá que completar todos los cuartos para limpiar el mundo, en lugar de buscar la ruta más corta para limpiar los cuartos sucios.