02-agents_lsg.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intelligente Agenten\n",
    "## Der Turing-Test\n",
    "1. Wie funktioniert der Turing-Test?\n",
    " - Fragesteller kommuniziert mit zwei Gesprächspartnern über Bildschirm und Tastatur. Einer der Gesprächspartner ist ein Mensch, der andere eine Maschine. Fragesteller muss zuornden, welcher Gesprächspartner die Maschine ist.\n",
    "2. Was braucht eine Maschine um den Test zu bestehen?\n",
    " - Möglichkeit Wissen zu extrahieren, Sprachverständnis, Schlussfolgern, Lernfähigkeit\n",
    "3. Was ist der totale Turing-Test?\n",
    " - Turing Test wird um Wahrnehmungsfähigkeit der Maschine und Möglichkeit der Objektmanipulation erweitert\n",
    "4. Was braucht eine Maschine um den totalen Turing-Test zu bestehen?\n",
    " - Zusätzlich zum normalen Turing-Test: Computer Vision + Robotik\n",
    "5. Welche Probleme existieren beim Turing-Test?\n",
    " - Nicht reproduzierbar, nicht konstruktiv, nicht mathematisch analysierbar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agenten\n",
    "1. Was ist ein Agent? Aus welchen Bestandteilen besteht ein Agent?\n",
    "     - Agent ist etwas, dass durch seine Sensoren seine Umwelt beobachten kann und mithilfe seiner Aktuatoren Aktionen in dieser Umwelt ausführen kann. Die Auswahl welche Aktion ausgeführt werden soll, wird von der Agentenfunktion bestimmt\n",
    "2. Diskutieren Sie die folgenden Begriffe. Geben Sie jeweils 2 Beispiele für:<br/>\n",
    "    a) Vollständig beobachtbare Umgebung.\n",
    "        - Sensoren geben zu jeder Zeit alle Beobachtungen der Umwelt zurück\n",
    "      \n",
    "    b) Nichtdeterministische Umgebung.\n",
    "        - Aktionen durch MÖGLICHE Auswirkungen beschrieben. Keine Wahrscheinlichkeiten zu Auswirkungen gegeben!\n",
    "      \n",
    "    c) Single-Agent Umgebung.\n",
    "        - nur ein Agent der Umwelt verändert\n",
    "     \n",
    "    d) Multi-Agent Umgebung.\n",
    "        - Mehrere Agenten/\"Mitspieler\".\n",
    "     \n",
    "    e) Umgebung mit diskretem Zustandsraum.\n",
    "        - Wie wird Zeit gemessen? Hier: endlich viele Zeitschritte mit \n",
    "     \n",
    "    f) Umgebung mit kontinuierlichem Zustandsraum.\n",
    "        - Hier: kontinuierliche Zeit und Variablenveränderung\n",
    "     \n",
    "    g) Einfache Reflex-Agenten.\n",
    "        - Aktionen basierend nur auf aktuellen Beobachtungen\n",
    "     \n",
    "    h) Modellbasierte Reflex-Agenten.\n",
    "        - vorherige Beobachtungen und Zustände der Umwelt speichern\n",
    "     \n",
    "    i) Zielbasierte Agenten.\n",
    "        - Agent möchte bestimmtes Ziel erreichen und wählt auf Grundlage des Ziels die Aktionen aus \n",
    "     \n",
    "    j) Lernfähige Agenten.\n",
    "        - Agenten beibringen, wie er sich in bestimmten Situationen verhalten soll\n",
    "     \n",
    "3. Was ist Rationalität?\n",
    "    - Das Ziel von Rationalität ist es, das zuvor festgelegte Erfolgsmaß (Nutzen) zu maximieren."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Der Staubsauger als Agent\n",
    "1. Implementieren Sie die Klasse ReflexVacuumAgent als einfachen Reflex-Agenten.\n",
    "2. Implementieren Sie die Klasse ModelBasedVacuumAgent als modellbasierten Agenten.\n",
    "3. Erweitern Sie die Implementierung der VacuumEnvironment, sodass es beliebig viele, auf einem 2D-Gitter angeordnete Positionen gibt. Erweitern Sie auch die Implementierung der beiden Agenten entsprechend, sodass diese sinnvoll in der neuen Umgebung agieren können"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "\n",
    "loc_A, loc_B = (0, 0), (1, 0) \n",
    "\n",
    "\n",
    "class Thing:\n",
    "    \"\"\"This represents any physical object that can appear in an Environment.\n",
    "    You subclass Thing to get the things you want. Each thing can have a\n",
    "    .__name__  slot (used for output only).\"\"\"\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '<{}>'.format(getattr(self, '__name__', self.__class__.__name__))\n",
    "\n",
    "    def is_alive(self):\n",
    "        \"\"\"Things that are 'alive' should return true.\"\"\"\n",
    "        return hasattr(self, 'alive') and self.alive\n",
    "\n",
    "    def show_state(self):\n",
    "        \"\"\"Display the agent's internal state. Subclasses should override.\"\"\"\n",
    "        print(\"I don't know how to show_state.\")\n",
    "\n",
    "    def display(self, canvas, x, y, width, height):\n",
    "        \"\"\"Display an image of this Thing on the canvas.\"\"\"\n",
    "        # Do we need this?\n",
    "        pass\n",
    "\n",
    "\n",
    "\n",
    "class Agent(Thing):\n",
    "    \"\"\"An Agent is a subclass of Thing with one required slot,\n",
    "    .program, which should hold a function that takes one argument, the\n",
    "    percept, and returns an action. (What counts as a percept or action\n",
    "    will depend on the specific environment in which the agent exists.)\n",
    "    Note that 'program' is a slot, not a method. If it were a method,\n",
    "    then the program could 'cheat' and look at aspects of the agent.\n",
    "    It's not supposed to do that: the program can only look at the\n",
    "    percepts. An agent program that needs a model of the world (and of\n",
    "    the agent itself) will have to build and maintain its own model.\n",
    "    There is an optional slot, .performance, which is a number giving\n",
    "    the performance measure of the agent in its environment.\"\"\"\n",
    "    def __init__(self, program):\n",
    "        self.program = program\n",
    "\n",
    "def TraceAgent(agent):\n",
    "    \"\"\"Wrap the agent's program to print its input and output. This will let\n",
    "    you see what the agent is doing in the environment.\"\"\"\n",
    "    old_program = agent.program\n",
    "\n",
    "    def new_program(percept):\n",
    "        action = old_program(percept)\n",
    "        print('{} perceives {} and does {}'.format(agent, percept, action))\n",
    "        return action\n",
    "    agent.program = new_program\n",
    "    return agent\n",
    "\n",
    "\n",
    "def ReflexVacuumAgent():\n",
    "    \"\"\"A reflex agent for the two-state vacuum environment. [see \"vacuum-environment.pdf\"]\"\"\"\n",
    "    def program(percept):\n",
    "        location, status = percept\n",
    "        if status == 'Dirty':\n",
    "            return 'Suck'\n",
    "        elif location == loc_A:\n",
    "            return 'Right'\n",
    "        elif location == loc_B:\n",
    "            return 'Left'\n",
    "    return Agent(program)\n",
    "\n",
    "\n",
    "\n",
    "def ModelBasedVacuumAgent():\n",
    "    \"\"\"An agent that keeps track of what locations are clean or dirty.\"\"\"\n",
    "    model = {loc_A: None, loc_B: None}\n",
    "\n",
    "    def program(percept):\n",
    "        \"\"\"Same as ReflexVacuumAgent, except if everything is clean, do NoOp.\"\"\"\n",
    "        location, status = percept\n",
    "        model[location] = status  # Update the model here\n",
    "        if model[loc_A] == model[loc_B] == 'Clean':\n",
    "            return 'NoOp'\n",
    "        elif status == 'Dirty':\n",
    "            return 'Suck'\n",
    "        elif location == loc_A:\n",
    "            return 'Right'\n",
    "        elif location == loc_B:\n",
    "            return 'Left'\n",
    "    return Agent(program)\n",
    "\n",
    "\n",
    "class Environment:\n",
    "    \"\"\"Abstract class representing an Environment. 'Real' Environment classes\n",
    "    inherit from this. Your Environment will typically need to implement:\n",
    "        percept:           Define the percept that an agent sees.\n",
    "        execute_action:    Define the effects of executing an action.\n",
    "                           Also update the agent.performance slot.\n",
    "    The environment keeps a list of .things and .agents (which is a subset\n",
    "    of .things). Each agent has a .performance slot, initialized to 0.\n",
    "    Each thing has a .location slot, even though some environments may not\n",
    "    need this.\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.things = []\n",
    "        self.agents = []\n",
    "\n",
    "    def thing_classes(self):\n",
    "        return []  # List of classes that can go into environment\n",
    "\n",
    "    def percept(self, agent):\n",
    "        \"\"\"Return the percept that the agent sees at this point. (Implement this.)\"\"\"\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def execute_action(self, agent, action):\n",
    "        \"\"\"Change the world to reflect this action. (Implement this.)\"\"\"\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def default_location(self, thing):\n",
    "        \"\"\"Default location to place a new thing with unspecified location.\"\"\"\n",
    "        return None\n",
    "\n",
    "    def exogenous_change(self):\n",
    "        \"\"\"If there is spontaneous change in the world, override this.\"\"\"\n",
    "        pass\n",
    "\n",
    "    def step(self):\n",
    "        \"\"\"Run the environment for one time step. If the\n",
    "        actions and exogenous changes are independent, this method will\n",
    "        do. If there are interactions between them, you'll need to\n",
    "        override this method.\"\"\"\n",
    "        actions = []\n",
    "        for agent in self.agents:\n",
    "            actions.append(agent.program(self.percept(agent)))\n",
    "        for (agent, action) in zip(self.agents, actions):\n",
    "            self.execute_action(agent, action)\n",
    "        self.exogenous_change()\n",
    "\n",
    "    def run(self, steps=1000):\n",
    "        \"\"\"Run the Environment for given number of time steps.\"\"\"\n",
    "        for step in range(steps):\n",
    "            self.step()\n",
    "\n",
    "    def list_things_at(self, location, tclass=Thing):\n",
    "        \"\"\"Return all things exactly at a given location.\"\"\"\n",
    "        return [thing for thing in self.things\n",
    "                if thing.location == location and isinstance(thing, tclass)]\n",
    "\n",
    "    def some_things_at(self, location, tclass=Thing):\n",
    "        \"\"\"Return true if at least one of the things at location\n",
    "        is an instance of class tclass (or a subclass).\"\"\"\n",
    "        return self.list_things_at(location, tclass) != []\n",
    "\n",
    "    def add_thing(self, thing, location=None):\n",
    "        \"\"\"Add a thing to the environment, setting its location. For\n",
    "        convenience, if thing is an agent program we make a new agent\n",
    "        for it. (Shouldn't need to override this.)\"\"\"\n",
    "        if not isinstance(thing, Thing):\n",
    "            thing = Agent(thing)\n",
    "        if thing in self.things:\n",
    "            print(\"Can't add the same thing twice\")\n",
    "        else:\n",
    "            thing.location = location if location is not None else self.default_location(thing)\n",
    "            self.things.append(thing)\n",
    "            if isinstance(thing, Agent):\n",
    "                thing.performance = 0\n",
    "                self.agents.append(thing)\n",
    "\n",
    "    def delete_thing(self, thing):\n",
    "        \"\"\"Remove a thing from the environment.\"\"\"\n",
    "        try:\n",
    "            self.things.remove(thing)\n",
    "        except ValueError as e:\n",
    "            print(e)\n",
    "            print(\"  in Environment delete_thing\")\n",
    "            print(\"  Thing to be removed: {} at {}\".format(thing, thing.location))\n",
    "            print(\"  from list: {}\".format([(thing, thing.location) for thing in self.things]))\n",
    "        if thing in self.agents:\n",
    "            self.agents.remove(thing)\n",
    "\n",
    "\n",
    "\n",
    "class TrivialVacuumEnvironment(Environment):\n",
    "\n",
    "    \"\"\"This environment has two locations, A and B. Each can be Dirty\n",
    "    or Clean. The agent perceives its location and the location's\n",
    "    status. This serves as an example of how to implement a simple\n",
    "    Environment.\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.status = {loc_A: random.choice(['Clean', 'Dirty']),\n",
    "                       loc_B: random.choice(['Clean', 'Dirty'])}\n",
    "\n",
    "    def thing_classes(self):\n",
    "        return [Wall, Dirt, ReflexVacuumAgent, RandomVacuumAgent,\n",
    "                TableDrivenVacuumAgent, ModelBasedVacuumAgent]\n",
    "\n",
    "    def percept(self, agent):\n",
    "        \"\"\"Returns the agent's location, and the location status (Dirty/Clean).\"\"\"\n",
    "        return (agent.location, self.status[agent.location])\n",
    "\n",
    "    def execute_action(self, agent, action):\n",
    "        \"\"\"Change agent's location and/or location's status; track performance.\n",
    "        Score 10 for each dirt cleaned; -1 for each move.\"\"\"\n",
    "        if action == 'Right':\n",
    "            agent.location = loc_B\n",
    "            agent.performance -= 1\n",
    "        elif action == 'Left':\n",
    "            agent.location = loc_A\n",
    "            agent.performance -= 1\n",
    "        elif action == 'Suck':\n",
    "            if self.status[agent.location] == 'Dirty':\n",
    "                agent.performance += 10\n",
    "            self.status[agent.location] = 'Clean'\n",
    "\n",
    "    def default_location(self, thing):\n",
    "        \"\"\"Agents start in either location at random.\"\"\"\n",
    "        return random.choice([loc_A, loc_B])\n",
    "    \n",
    "    \n",
    "def AdvancedReflexVacuumAgent():\n",
    "\n",
    "    def program(percept):\n",
    "        location, status = percept\n",
    "        if status == 'Dirty':\n",
    "            return 'Suck'\n",
    "        elif location[\"x\"] < x_size -1 and location[\"y\"] % 2 == 0:\n",
    "            return 'Right'\n",
    "        elif location[\"x\"] > 0 and location[\"y\"] % 2 != 0:\n",
    "            return 'Left'\n",
    "        elif location[\"y\"] < y_size -1 and location[\"x\"] % 2 == 0:\n",
    "            return 'Down'\n",
    "        elif location[\"y\"] > 0 and location[\"x\"] % 2 != 0:\n",
    "            return 'Up'\n",
    "        else: # Wenn er in der untersten Ecke angekommen ist, fährt er in die oberste rechte Ecke\n",
    "            return \"Restart\"\n",
    "    return Agent(program)\n",
    "\n",
    "def AdvancedModelBasedVacuumAgent():\n",
    "    # Hier merkt sich der Roboter seine Startposition. Wenn er diese neu erreicht, ist er fertig\n",
    "    model = {\"visited_positions\": []}\n",
    "\n",
    "    def program(percept):\n",
    "        location, status = percept\n",
    "        if location in model[\"visited_positions\"]:\n",
    "            return \"Finished\"\n",
    "        elif status == 'Dirty':\n",
    "            return 'Suck'\n",
    "        elif location[\"x\"] < x_size -1 and location[\"y\"] % 2 == 0:\n",
    "            model[\"visited_positions\"].append(location.copy())\n",
    "            return 'Right'\n",
    "        elif location[\"x\"] > 0 and location[\"y\"] % 2 != 0:\n",
    "            model[\"visited_positions\"].append(location.copy())\n",
    "            return 'Left'\n",
    "        elif location[\"y\"] < y_size -1 and location[\"x\"] % 2 == 0:\n",
    "            model[\"visited_positions\"].append(location.copy())\n",
    "            return 'Down'\n",
    "        else: # Wenn er in der untersten linken Ecke angekommen ist, fährt er in die oberste linke Ecke\n",
    "            return \"Restart\"\n",
    "    return Agent(program)\n",
    "    \n",
    "x_size = 5\n",
    "y_size = 10 \n",
    "    \n",
    "class AdvancedVacuumEnvironment(Environment):\n",
    "    \"\"\"This environment has locations on a 2d grid. Each can be Dirty\n",
    "    or Clean. The agent perceives its location and the location's\n",
    "    status. This serves as an example of how to implement a advanced\n",
    "    Environment.\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.status = np.array([[random.choice(['Clean', 'Dirty']) for j in range(y_size)] for i in range(x_size)])\n",
    "\n",
    "    def thing_classes(self):\n",
    "        return [Wall, Dirt, ReflexVacuumAgent, RandomVacuumAgent,\n",
    "                TableDrivenVacuumAgent, ModelBasedVacuumAgent]\n",
    "\n",
    "    def percept(self, agent):\n",
    "        \"\"\"Returns the agent's location, and the location status (Dirty/Clean).\"\"\"\n",
    "        x = agent.location[\"x\"]\n",
    "        y = agent.location[\"y\"]\n",
    "        return (agent.location, self.status[x,y])\n",
    "\n",
    "    def execute_action(self, agent, action):\n",
    "        \"\"\"Change agent's location and/or location's status; track performance.\n",
    "        Score 10 for each dirt cleaned; -1 for each move.\"\"\"\n",
    "        if action == 'Right':\n",
    "            agent.location[\"x\"] = agent.location[\"x\"]+1\n",
    "            agent.performance -= 1\n",
    "        elif action == 'Left':\n",
    "            agent.location[\"x\"] = agent.location[\"x\"]-1\n",
    "            agent.performance -= 1\n",
    "        elif action == 'Down':\n",
    "            agent.location[\"y\"] = agent.location[\"y\"]+1\n",
    "            agent.performance -= 1\n",
    "        elif action == 'Restart':\n",
    "            agent.location[\"x\"] = 0\n",
    "            agent.location[\"y\"] = 0\n",
    "        elif action == 'Suck':\n",
    "            if self.status[agent.location[\"x\"], agent.location[\"y\"]] == 'Dirty':\n",
    "                agent.performance += 10\n",
    "            self.status[agent.location[\"x\"], agent.location[\"y\"]] = 'Clean'\n",
    "        else:\n",
    "            return\n",
    "\n",
    "    def default_location(self, thing):\n",
    "        \"\"\"Agents start in either location at random.\"\"\"\n",
    "        location = {\"x\": random.randrange(x_size), \"y\": random.randrange(y_size)}\n",
    "        return location"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier ein Beispiel-Aufruf für den Agenten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ReflexAgent:\n",
      "<Agent> perceives ((0, 0), 'Clean') and does Right\n",
      "<Agent> perceives ((1, 0), 'Clean') and does Left\n",
      "<Agent> perceives ((0, 0), 'Dirty') and does Suck\n",
      "<Agent> perceives ((1, 0), 'Dirty') and does Suck\n",
      "\n",
      "ModelBasedAgent:\n",
      "<Agent> perceives ((0, 0), 'Dirty') and does Suck\n",
      "<Agent> perceives ((0, 0), 'Clean') and does Right\n",
      "<Agent> perceives ((1, 0), 'Dirty') and does Suck\n",
      "<Agent> perceives ((1, 0), 'Clean') and does NoOp\n",
      "<Agent> perceives ((1, 0), 'Clean') and does NoOp\n",
      "\n",
      "AdvancedEnvironment:\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 2, 'y': 8}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 2, 'y': 8}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 3, 'y': 8}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 3, 'y': 8}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 4, 'y': 8}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 4, 'y': 9}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 4, 'y': 9}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 3, 'y': 9}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 2, 'y': 9}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 1, 'y': 9}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 1, 'y': 9}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 0, 'y': 9}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 0, 'y': 9}, 'Clean') and does Restart\n",
      "<Agent> perceives ({'x': 0, 'y': 0}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 1, 'y': 0}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 2, 'y': 0}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 3, 'y': 0}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 3, 'y': 0}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 4, 'y': 0}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 4, 'y': 1}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 4, 'y': 1}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 3, 'y': 1}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 3, 'y': 1}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 2, 'y': 1}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 2, 'y': 1}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 1, 'y': 1}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 0, 'y': 1}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 0, 'y': 2}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 1, 'y': 2}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 2, 'y': 2}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 2, 'y': 2}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 3, 'y': 2}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 3, 'y': 2}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 4, 'y': 2}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 4, 'y': 3}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 4, 'y': 3}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 3, 'y': 3}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 3, 'y': 3}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 2, 'y': 3}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 2, 'y': 3}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 1, 'y': 3}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 0, 'y': 3}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 0, 'y': 4}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 1, 'y': 4}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 1, 'y': 4}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 2, 'y': 4}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 3, 'y': 4}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 4, 'y': 4}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 4, 'y': 5}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 3, 'y': 5}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 2, 'y': 5}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 2, 'y': 5}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 1, 'y': 5}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 0, 'y': 5}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 0, 'y': 6}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 0, 'y': 6}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 1, 'y': 6}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 2, 'y': 6}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 2, 'y': 6}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 3, 'y': 6}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 3, 'y': 6}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 4, 'y': 6}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 4, 'y': 6}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 4, 'y': 7}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 4, 'y': 7}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 3, 'y': 7}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 3, 'y': 7}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 2, 'y': 7}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 1, 'y': 7}, 'Dirty') and does Suck\n",
      "<Agent> perceives ({'x': 1, 'y': 7}, 'Clean') and does Left\n",
      "<Agent> perceives ({'x': 0, 'y': 7}, 'Clean') and does Down\n",
      "<Agent> perceives ({'x': 0, 'y': 8}, 'Clean') and does Right\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Clean') and does Finished\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Clean') and does Finished\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Clean') and does Finished\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Clean') and does Finished\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Clean') and does Finished\n",
      "<Agent> perceives ({'x': 1, 'y': 8}, 'Clean') and does Finished\n"
     ]
    }
   ],
   "source": [
    "print(\"ReflexAgent:\")\n",
    "a = TraceAgent(ReflexVacuumAgent())\n",
    "a.program((loc_A, 'Clean'))\n",
    "a.program((loc_B, 'Clean'))\n",
    "a.program((loc_A, 'Dirty'))\n",
    "a.program((loc_B, 'Dirty'))\n",
    "\n",
    "print(\"\\nModelBasedAgent:\")\n",
    "e = TrivialVacuumEnvironment()\n",
    "e.add_thing(TraceAgent(ModelBasedVacuumAgent()))\n",
    "e.run(5)\n",
    "\n",
    "print(\"\\nAdvancedEnvironment:\")\n",
    "e = AdvancedVacuumEnvironment()\n",
    "e.add_thing(TraceAgent(AdvancedModelBasedVacuumAgent()))\n",
    "e.run(80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}