Agent.__init__ now takes a program parameter. A few more nonlocal-state-variable problems found and fixed. One agent program rewritten as a callable instance since it uses both state variables and abstract methods.

darius · darius · commit bc88cd3df588 · 2011-10-10T19:06:36.000Z
diff --git a/agents.py b/agents.py
@@ -73,11 +73,12 @@ class Agent(Object):
     There is an optional slots, .performance, which is a number giving
     the performance measure of the agent in its environment."""
 
-    def __init__(self):
+    def __init__(self, program=None):
         self.alive = True
         self.bump = False
-        def program(percept):
-            return raw_input('Percept=%s; action? ' % percept)
+        if program is None:
+            def program(percept):
+                return raw_input('Percept=%s; action? ' % percept)
         self.program = program
 
     def can_grab(self, obj):
@@ -107,21 +108,21 @@ def __init__(self, table):
         "Supply as table a dictionary of all {percept_sequence:action} pairs."
         ## The agent program could in principle be a function, but because
         ## it needs to store state, we make it a callable instance of a class.
-        super(TableDrivenAgent, self).__init__()
         percepts = []
         def program(percept):
             percepts.append(percept)
             action = table.get(tuple(percepts))
             return action
-        self.program = program
+        Agent.__init__(self, program)
 
 
 class RandomAgent(Agent):
     "An agent that chooses an action at random, ignoring all percepts."
 
     def __init__(self, actions):
-        super(RandomAgent, self).__init__()
-        self.program = lambda percept: random.choice(actions)
+        def program(percept):
+            return random.choice(actions)
+        Agent.__init__(self, program)
 
 
 #______________________________________________________________________________
@@ -132,12 +133,11 @@ class ReflexVacuumAgent(Agent):
     "A reflex agent for the two-state vacuum environment. [Fig. 2.8]"
 
     def __init__(self):
-        super(ReflexVacuumAgent, self).__init__()
         def program((location, status)):
             if status == 'Dirty': return 'Suck'
             elif location == loc_A: return 'Right'
             elif location == loc_B: return 'Left'
-        self.program = program
+        Agent.__init__(self, program)
 
 def RandomVacuumAgent():
     "Randomly choose one of the actions from the vacuum environment."
@@ -164,7 +164,6 @@ class ModelBasedVacuumAgent(Agent):
     "An agent that keeps track of what locations are clean or dirty."
 
     def __init__(self):
-        super(ModelBasedVacuumAgent, self).__init__()
         model = {loc_A: None, loc_B: None}
         def program((location, status)):
             "Same as ReflexVacuumAgent, except if everything is clean, do NoOp"
@@ -173,7 +172,7 @@ def program((location, status)):
             elif status == 'Dirty': return 'Suck'
             elif location == loc_A: return 'Right'
             elif location == loc_B: return 'Left'
-        self.program = program
+        Agent.__init__(self, program)
 
 #______________________________________________________________________________
 
@@ -454,26 +453,24 @@ class SimpleReflexAgent(Agent):
     """This agent takes action based solely on the percept. [Fig. 2.13]"""
 
     def __init__(self, rules, interpret_input):
-        super(SimpleReflexAgent, self).__init__()
         def program(percept):
             state = interpret_input(percept)
             rule = rule_match(state, rules)
             action = rule.action
             return action
-        self.program = program
+        Agent.__init__(self, program)
 
 class ReflexAgentWithState(Agent):
     """This agent takes action based on the percept and state. [Fig. 2.16]"""
 
     def __init__(self, rules, update_state):
-        super(ReflexAgentWithState, self).__init__()
-        state = [None]
         def program(percept):
-            state[0] = update_state(state[0], action, percept)
-            rule = rule_match(state[0], rules)
+            program.state = update_state(program.state, program.action, percept)
+            rule = rule_match(program.state, rules)
             action = rule.action
             return action
-        return program
+        program.state = program.action = None
+        Agent.__init__(self, program)
 
 def rule_match(state, rules):
     "Find the first rule that matches state."
diff --git a/logic.py b/logic.py
@@ -94,15 +94,14 @@ def retract(self, sentence):
 class KB_Agent(agents.Agent):
     """A generic logical knowledge-based agent. [Fig. 7.1]"""
     def __init__(self, KB):
-        agents.Agent.__init__(self)
         steps = itertools.count()
         def program(percept):
             t = steps.next()
             KB.tell(self.make_percept_sentence(percept, t))
             action = KB.ask(self.make_action_query(t))[expr('action')]
             KB.tell(self.make_action_sentence(action, t))
             return action
-        self.program = program
+        agents.Agent.__init__(self, program)
 
     def make_percept_sentence(self, percept, t):
         return Expr("Percept")(percept, t)
@@ -745,30 +744,31 @@ def WalkSAT(clauses, p=0.5, max_flips=10000):
 class PLWumpusAgent(agents.Agent):
     "An agent for the wumpus world that does logical inference. [Fig. 7.19]"""
     def __init__(self):
-        agents.Agent.__init__(self)
         KB = FolKB() ## shouldn't this be a propositional KB? ***
         x, y, orientation = 1, 1, (1, 0)
         visited = set() ## squares already visited
-        action = None
         plan = []
 
         def program(percept):
             stench, breeze, glitter = percept
-            x, y, orientation = update_position(x, y, orientation, action)
+            x, y, orientation = \
+                update_position(x, y, orientation, program.action)
             KB.tell('%sS_%d,%d' % (if_(stench, '', '~'), x, y))
             KB.tell('%sB_%d,%d' % (if_(breeze, '', '~'), x, y))
-            if glitter: action = 'Grab'
-            elif plan: action = plan.pop()
+            if glitter: program.action = 'Grab'
+            elif plan: program.action = plan.pop()
             else:
                 for [i, j] in fringe(visited):
                     if KB.ask('~P_%d,%d & ~W_%d,%d' % (i, j, i, j)) != False:
                         raise NotImplementedError
                     KB.ask('~P_%d,%d | ~W_%d,%d' % (i, j, i, j)) != False 
-            if action is None: 
-                action = random.choice(['Forward', 'Right', 'Left'])
-            return action
+            if program.action is None: 
+                program.action = random.choice(['Forward', 'Right', 'Left'])
+            return program.action
+
+        program.action = None
 
-        return program
+        agents.Agent.__init__(self, program)
 
 def update_position(x, y, orientation, action):
     if action == 'TurnRight':
diff --git a/probability.py b/probability.py
@@ -12,16 +12,13 @@ class DTAgent(agents.Agent):
     "A decision-theoretic agent. [Fig. 13.1]"
 
     def __init__(self, belief_state):
-        agents.Agent.__init__(self)
-
         def program(percept):
-            belief_state.observe(action, percept)
+            belief_state.observe(program.action, percept)
             program.action = argmax(belief_state.actions(), 
                                     belief_state.expected_outcome_utility)
             return program.action
-
         program.action = None
-        self.program = program
+        agents.Agent.__init__(self, program)
 
 #______________________________________________________________________________
 
diff --git a/search.py b/search.py
@@ -88,29 +88,32 @@ def expand(self, problem):
 
 #______________________________________________________________________________
 
-class SimpleProblemSolvingAgent(agents.Agent):
-    """Abstract framework for problem-solving agent. [Fig. 3.1]"""
-    def __init__(self):
-        # Some nits in this code:
-        # - We're requiring state to be a list so it can be
-        #   updated as a nonlocal variable.
-        # - The agent program calls self.foo() methods,
-        #   against the usual policy that agent programs
-        #   be self-contained.
-        agents.Agent.__init__(self)
-        state = []
-        seq = []
-
-        def program(percept):
-            state[:] = self.update_state(state, percept)
-            if not seq:
-                goal = self.formulate_goal(state)
-                problem = self.formulate_problem(state, goal)
-                seq[:] = self.search(problem)
-                if not seq: return None
-            return seq.pop(0)
-
-        self.program = program
+class SimpleProblemSolvingAgentProgram:
+    """Abstract framework for a problem-solving agent. [Fig. 3.1]"""
+    def __init__(self, initial_state=None):
+        update(self, state=initial_state, seq=[])
+
+    def __call__(self, percept):
+        self.state = self.update_state(self.state, percept)
+        if not self.seq:
+            goal = self.formulate_goal(self.state)
+            problem = self.formulate_problem(self.state, goal)
+            self.seq = self.search(problem)
+            if not self.seq: return None
+        return self.seq.pop(0)
+
+    def update_state(self, percept):
+        abstract
+
+    def formulate_goal(self, state):
+        abstract
+
+    def formulate_problem(self, state, goal):
+        abstract
+
+    def search(self, problem):
+        abstract
+
 #______________________________________________________________________________
 ## Uninformed Search algorithms
 
