def test_TableDrivenAgent(): loc_A, loc_B = (0, 0), (1, 0) # table defining all the possible states of the agent table = {((loc_A, 'Clean'),): 'Right', ((loc_A, 'Dirty'),): 'Suck', ((loc_B, 'Clean'),): 'Left', ((loc_B, 'Dirty'),): 'Suck', ((loc_A, 'Dirty'), (loc_A, 'Clean')): 'Right', ((loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck', ((loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck', ((loc_B, 'Dirty'), (loc_B, 'Clean')): 'Left', ((loc_A, 'Dirty'), (loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck', ((loc_B, 'Dirty'), (loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck' } # create an program and then an object of the TableDrivenAgent program = TableDrivenAgentProgram(table) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # initializing some environment status environment.status = {loc_A:'Dirty', loc_B:'Dirty'} # add agent to the environment environment.add_thing(agent) # run the environment by single step everytime to check how environment evolves using TableDrivenAgentProgram environment.run(steps = 1) assert environment.status == {(1,0): 'Clean', (0,0): 'Dirty'} environment.run(steps = 1) assert environment.status == {(1,0): 'Clean', (0,0): 'Dirty'} environment.run(steps = 1) assert environment.status == {(1,0): 'Clean', (0,0): 'Clean'}
def test_SimpleReflexAgentProgram(): class Rule: def __init__(self, state, action): self.__state = state self.action = action def matches(self, state): return self.__state == state loc_A = (0, 0) loc_B = (1, 0) # create rules for a two state Vacuum Environment rules = [Rule((loc_A, "Dirty"), "Suck"), Rule((loc_A, "Clean"), "Right"), Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left")] def interpret_input(state): return state # create a program and then an object of the SimpleReflexAgentProgram program = SimpleReflexAgentProgram(rules, interpret_input) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1,0):'Clean' , (0,0) : 'Clean'}
def test_RandomVacuumAgent() : # create an object of the RandomVacuumAgent agent = RandomVacuumAgent() # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1,0):'Clean' , (0,0) : 'Clean'}
def test_RandomAgentProgram() : #create a list of all the actions a vacuum cleaner can perform list = ['Right', 'Left', 'Suck', 'NoOp'] # create a program and then an object of the RandomAgentProgram program = RandomAgentProgram(list) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1, 0): 'Clean' , (0, 0): 'Clean'}
def test_ModelBasedReflexAgentProgram(): class Rule: def __init__(self, state, action): self.__state = state self.action = action def matches(self, state): return self.__state == state loc_A = (0, 0) loc_B = (1, 0) # create rules for a two-state vacuum environment rules = [ Rule((loc_A, "Dirty"), "Suck"), Rule((loc_A, "Clean"), "Right"), Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left") ] def update_state(state, action, percept, model): return percept # create a program and then an object of the ModelBasedReflexAgentProgram class program = ModelBasedReflexAgentProgram(rules, update_state, None) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
def test_SimpleReflexAgentProgram(): class Rule: def __init__(self, state, action): self.__state = state self.action = action def matches(self, state): return self.__state == state loc_A = (0, 0) loc_B = (1, 0) # create rules for a two state Vacuum Environment rules = [ Rule((loc_A, "Dirty"), "Suck"), Rule((loc_A, "Clean"), "Right"), Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left") ] def interpret_input(state): return state # create a program and then an object of the SimpleReflexAgentProgram program = SimpleReflexAgentProgram(rules, interpret_input) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
def test_TableDrivenAgent() : #create a table that would consist of all the possible states of the agent loc_A, loc_B = (0, 0), (1, 0) table = {((loc_A, 'Clean'),): 'Right', ((loc_A, 'Dirty'),): 'Suck', ((loc_B, 'Clean'),): 'Left', ((loc_B, 'Dirty'),): 'Suck', ((loc_A, 'Dirty'), (loc_A, 'Clean')): 'Right', ((loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck', ((loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck', ((loc_B, 'Dirty'), (loc_B, 'Clean')): 'Left', ((loc_A, 'Dirty'), (loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck', ((loc_B, 'Dirty'), (loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck' } # create an program and then an object of the TableDrivenAgent program = TableDrivenAgentProgram(table) agent = Agent(program) # create an object of the TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
def Model(start, a, b): print("---Start: {}, (0,0):{} (1,0):{}---".format(start, a, b)) agent = ReflexVacuumAgent() env = TrivialVacuumEnvironment() env.add_thing(agent, start) env.status = {(1, 0): b, (0, 0): a} while (env.status != {(1, 0): 'Clean', (0, 0): 'Clean'}): env.step() return env.agents[0].performance
def test_RandomVacuumAgent(): # create an object of the RandomVacuumAgent agent = RandomVacuumAgent() # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
def test_RandomAgentProgram(): #create a list of all the actions a vacuum cleaner can perform list = ['Right', 'Left', 'Suck', 'NoOp'] # create a program and then an object of the RandomAgentProgram program = RandomAgentProgram(list) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
def test_TableDrivenAgent(): loc_A, loc_B = (0, 0), (1, 0) # table defining all the possible states of the agent table = { ((loc_A, 'Clean'), ): 'Right', ((loc_A, 'Dirty'), ): 'Suck', ((loc_B, 'Clean'), ): 'Left', ((loc_B, 'Dirty'), ): 'Suck', ((loc_A, 'Dirty'), (loc_A, 'Clean')): 'Right', ((loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck', ((loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck', ((loc_B, 'Dirty'), (loc_B, 'Clean')): 'Left', ((loc_A, 'Dirty'), (loc_A, 'Clean'), (loc_B, 'Dirty')): 'Suck', ((loc_B, 'Dirty'), (loc_B, 'Clean'), (loc_A, 'Dirty')): 'Suck' } # create an program and then an object of the TableDrivenAgent program = TableDrivenAgentProgram(table) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # initializing some environment status environment.status = {loc_A: 'Dirty', loc_B: 'Dirty'} # add agent to the environment environment.add_thing(agent) # run the environment by single step everytime to check how environment evolves using TableDrivenAgentProgram environment.run(steps=1) assert environment.status == {(1, 0): 'Clean', (0, 0): 'Dirty'} environment.run(steps=1) assert environment.status == {(1, 0): 'Clean', (0, 0): 'Dirty'} environment.run(steps=1) assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
def test_ModelBasedReflexAgentProgram(): loc_A = (0, 0) loc_B = (1, 0) model = {loc_A: None, loc_B: None} class Rule: def __init__(self, state, action): self.__state = state self.action = action def matches(self, state): return self.__state == state # create rules for a two state Vacuum Environment rules = [ Rule((loc_A, "Dirty"), "Suck"), Rule((loc_A, "Clean"), "Right"), Rule((loc_B, "Dirty"), "Suck"), Rule((loc_B, "Clean"), "Left") ] def update_state(state, action, percept, model): loc, status = percept # the other location loc2 = tuple(map(lambda x: x[0] - x[1], zip((1, 0), loc))) # initial guess of the other location if not state or not action or not model[loc2]: model[loc2] = random.choice(['Dirty', 'Clean']) model[loc] = status # the model think environment will keep clean if agent chose to suck last step if action == 'Suck': state = percept return state # rubbish may appears suddenly, so the model guess randomly if status == 'Clean': status = random.choice(['Dirty', 'Clean']) model[loc] = status # move right or left will not influence the environment state = (loc, model[loc]) return state # create a program and then an object of the ModelBasedReflexAgentProgram program = ModelBasedReflexAgentProgram(rules, update_state, model) agent = Agent(program) # create an object of TrivialVacuumEnvironment environment = TrivialVacuumEnvironment() # add agent to the environment environment.add_thing(agent) # run the environment environment.run() # check final status of the environment assert environment.status == {(1, 0): 'Clean', (0, 0): 'Clean'}
ReflexVacuumAgent, TrivialVacuumEnvironment, ) from utils import ( mean, ) # Exercise 2.7 print "\n\nExercise 2.7" n=100 steps=4 print "Compare ReflexVacuumAgent against {n} TrivialVacuumEnvironment instances and {steps} steps".format(**locals()) print compare_agents(TrivialVacuumEnvironment, [ReflexVacuumAgent], n=n, steps=4) # Exercise 2.8 # Run the environment simulator with a simple reflex agent for all possible # initial dirt configurations and agent locations print "\n\nExercise 2.8" scores = [] for loc_A_status in ('Clean', 'Dirty'): for loc_B_status in ('Clean', 'Dirty'): for agent_loc in (loc_A, loc_B): agent = ReflexVacuumAgent() env = TrivialVacuumEnvironment(loc_A_status, loc_B_status) env.add_thing(agent, agent_loc) env.run(steps) scores.append(agent.performance) print "Environment=({loc_A_status}, {loc_B_status}) and agent at {agent_loc}, agent scored {agent.performance} in {steps} steps".format(**locals()) print "Mean score {}".format(mean(scores))