Newer
Older
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# AGENT #\n",
"\n",
"An agent, as defined in 2.1 is anything that can perceive its <b>environment</b> through sensors, and act upon that environment through actuators based on its <b>agent program</b>. This can be a dog, robot, or even you. As long as you can perceive the environment and act on it, you are an agent. This notebook will explain how to implement a simple agent, create an environment, and create a program that helps the agent act on the environment based on its percepts.\n",
"\n",
"Before moving on, review the </b>Agent</b> and </b>Environment</b> classes in <b>[agents.py](https://github.com/aimacode/aima-python/blob/master/agents.py)</b>.\n",
"\n",
"Let's begin by importing all the functions from the agents.py module and creating our first agent - a blind dog."
]
},
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
"execution_count": 29,
"metadata": {
"collapsed": false,
"scrolled": true
},
"outputs": [],
"source": [
"from agents import *\n",
"\n",
"class BlindDog(Agent):\n",
" def eat(self, thing):\n",
" print(\"Dog: Ate food at {}.\".format(self.location))\n",
" \n",
" def drink(self, thing):\n",
" print(\"Dog: Drank water at {}.\".format( self.location))\n",
"\n",
"dog = BlindDog()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What we have just done is create a dog who can only feel what's in his location (since he's blind), and can eat or drink. Let's see if he's alive..."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(dog.alive)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"This is our dog. How cool is he? Well, he's hungry and needs to go search for food. For him to do this, we need to give him a program. But before that, let's create a park for our dog to play in."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# ENVIRONMENT #\n",
"\n",
"A park is an example of an environment because our dog can perceive and act upon it. The <b>Environment</b> class in agents.py is an abstract class, so we will have to create our own subclass from it before we can use it. The abstract class must contain the following methods:\n",
"\n",
"<li><b>percept(self, agent)</b> - returns what the agent perceives</li>\n",
"<li><b>execute_action(self, agent, action)</b> - changes the state of the environment based on what the agent does.</li>"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"class Food(Thing):\n",
" pass\n",
"\n",
"class Water(Thing):\n",
" pass\n",
"\n",
"class Park(Environment):\n",
" '''prints & return a list of things that are in our dog's location'''\n",
" def percept(self, agent):\n",
" things = self.list_things_at(agent.location)\n",
" print(things)\n",
" return things\n",
" \n",
" def execute_action(self, agent, action):\n",
" '''changes the state of the environment based on what the agent does.'''\n",
" if action == \"move down\":\n",
" agent.movedown()\n",
" elif action == \"eat\":\n",
" items = self.list_things_at(agent.location, tclass=Food)\n",
" if len(items) != 0:\n",
" if agent.eat(items[0]): #Have the dog pick eat the first item\n",
" self.delete_thing(items[0]) #Delete it from the Park after.\n",
" elif action == \"drink\":\n",
" items = self.list_things_at(agent.location, tclass=Water)\n",
" if len(items) != 0:\n",
" if agent.drink(items[0]): #Have the dog drink the first item\n",
" self.delete_thing(items[0]) #Delete it from the Park after.\n",
" \n",
" def is_done(self):\n",
" '''By default, we're done when we can't find a live agent, \n",
" but to prevent killing our cute dog, we will or it with when there is no more food or water'''\n",
" no_edibles = not any(isinstance(thing, Food) or isinstance(thing, Water) for thing in self.things)\n",
" dead_agents = not any(agent.is_alive() for agent in self.agents)\n",
" return dead_agents or no_edibles\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"# PROGRAM #\n",
"Now that we have a <b>Park</b> Class, we need to implement a <b>program</b> module for our dog. A program controls how the dog acts upon it's environment. Our program will be very simple, and is shown in the table below.\n",
"<table>\n",
" <tr>\n",
" <td><b>Percept:</b> </td>\n",
" <td>Feel Food </td>\n",
" <td>Feel Water</td>\n",
" <td>Feel Nothing</td>\n",
" </tr>\n",
" <tr>\n",
" <td><b>Action:</b> </td>\n",
" <td>eat</td>\n",
" <td>drink</td>\n",
" <td>move up</td>\n",
" </tr>\n",
" \n",
"</table>\n"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false
},
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
"class BlindDog(Agent):\n",
" location = 1\n",
" \n",
" def movedown(self):\n",
" self.location += 1\n",
" \n",
" def eat(self, thing):\n",
" '''returns True upon success or False otherwise'''\n",
" if isinstance(thing, Food):\n",
" print(\"Dog: Ate food at {}.\".format(self.location))\n",
" return True\n",
" return False\n",
" \n",
" def drink(self, thing):\n",
" ''' returns True upon success or False otherwise'''\n",
" if isinstance(thing, Water):\n",
" print(\"Dog: Drank water at {}.\".format(self.location))\n",
" return True\n",
" return False\n",
" \n",
"def program(percepts):\n",
" '''Returns an action based on it's percepts'''\n",
" for p in percepts:\n",
" if isinstance(p, Food):\n",
" return 'eat'\n",
" elif isinstance(p, Water):\n",
" return 'drink'\n",
" return 'move down'\n",
" \n",
" "
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[<BlindDog>]\n",
"[<BlindDog>]\n",
"[<BlindDog>]\n",
"[<BlindDog>]\n",
"[<BlindDog>]\n",
"[<BlindDog>, <Food>]\n",
"Dog: Ate food at 5.\n",
"[<BlindDog>]\n",
"[<BlindDog>]\n",
"[<BlindDog>, <Water>]\n",
"Dog: Drank water at 7.\n"
]
}
],
"source": [
"park = Park()\n",
"dog = BlindDog(program)\n",
"dogfood = Food()\n",
"water = Water()\n",
"park.add_thing(dog, 0)\n",
"park.add_thing(dogfood, 5)\n",
"park.add_thing(water, 7)\n",
"\n",
"park.run(10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That's how easy it is to implement an agent, its program, and environment. But that was a very simple case. What if our environment was 2-Dimentional instead of 1? And what if we had multiple agents?"
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"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.5.1"
}
},
"nbformat": 4,
"nbformat_minor": 0
}