"execution_count": 2,

"*In the end of this notebook, you can see how different searching algorithms solves the route finding problem defined on romania map.*"

"sdc"

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"## Uninformed Search Strategies"

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"\n",

" \n",

"The `Problem` class is an abstract class on which we define our problems(*duh*).\n",

"Again, if you are confused about what `abstract class` means have a look at the `Intro` notebook.\n",

"* `__init__(self, initial, goal)` : This is what is called a `constructor` and is the first method called when you create an instance of class. In this and all of the below methods `self` refers to the object itself--the object whose method is called. `initial` specifies the initial state of our search problem. It represents the start state from where our agent begins his task of exploration to find the goal state(s) which is given in the `goal` parameter.\n",

"* `actions(self, state)` : This method returns all the possible actions our agent can make in state `state`.\n",

"Now the above abstract class acts as a parent class, and there is another named called `GraphProblem` in our module. It creates a graph problem from an instance of the `Graph` class. To create a graph, simply type `graph = Graph(dict(...))`. The dictionary must contain nodes of the graph as keys, so make sure they are `hashable`. If you don't know what that means just use strings or numbers. Each node contains the adjacent nodes as keys and the edge length as its value. Each dictionary then should correspond to another dictionary in the graph. The `Graph` class creates a directed(edges allow only one way traffic) by default. If you want to make an undirected graph, use `UndirectedGraph` instead, but make sure to mention any edge in only one of its nodes."

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"If you didn't understand the above paragraph, `Fret not!`. Just think of the below code as a magicical method to create a simple undirected graph. I'll explain what it is about later."

"execution_count": 2,

"museum_graph = UndirectedGraph(dict(\n",

" Start = dict(Dog = 3, Cat = 9, Mouse = 4),\n",

" Dog = dict(Bear = 7),\n",

" Cat = dict(Monkey = 9, Fish = 8, Penguin = 3),\n",

" Mouse = dict(Penguin = 2),\n",

" Bear = dict(Monkey = 7),\n",

" Monkey = dict(Giraffe = 11, Fish = 6),\n",

" Fish = dict(Giraffe = 8),\n",

" Penguin = dict(Parrot = 4, Elephant = 6),\n",

" Giraffe = dict(Hen = 5),\n",

" Parrot = dict(Hen = 10),\n",

" Elephant = dict(Hen = 9)))"

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"Imagine we are in a museum showcasing statues of various animals. To navigate through the museum there are paths between some statues and the entrance. We define the entrance and the statues as nodes in our graph with the path connecting them as edges. The cost/weight of an edge specifies is its length. So `Start = dict(Dog = 3, Cat = 9, Mouse = 4)` means that there are paths from `Start` to `Dog`, `Cat` and `Mouse` with path costs 3, 9 and 4 respectively. \n",

"\n",

"Here's an image below to better understand our graph."

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"<img src=\"images/search_animal.svg\" width=\"80%\">\n",

"<!-- Theses lovely animal icons were reproduced courtesy of Creative Tail https://www.creativetail.com/40-free-flat-animal-icons/ -->\n"

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"### Breadth First Search"

"In Breadth First Search, the `shallowest` unexpanded node is chosen for expansion. That means that all nodes of a given depth must be expanded before any node of the next depth level. This search strategy accomplishes this by using a `FIFO` meaning 'First In First Out' queue. Anything that gets in the queue first also gets out first just like the checkout queue in a supermarket. To use the algorithm, first we need to define our problem. Say we want to find the statue of `Monkey` and we start from the entrance which is the `Start` state. We'll define our problem using the `GraphProblem` class."

"execution_count": 3,

"monkey_problem = GraphProblem('Start', 'Monkey', museum_graph)"

"metadata": {},

"source": [

"Now let's find the solution for our problem using the `breadth_first_search` method. Note that it returns a `Node` from which we can find the solution by looking at the path that was taken to reach there."

]

},

{

"cell_type": "code",

"execution_count": 4,

"collapsed": false

},

"outputs": [

{

"data": {

"text/plain": [

"['Cat', 'Monkey']"

]

},

"execution_count": 4,

"metadata": {},

"output_type": "execute_result"

}

],

"source": [

"bfs_node = breadth_first_search(monkey_problem)\n",

"bfs_node.solution()"

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"We get the output as `['Cat', 'Monkey']`. That is because first the nodes `Dog`, `Cat` and `Mouse` are added to the `FIFO` queue in `some` order when we are expanding the `Start` node. Now when we start expanding nodes in the next level, only the `Cat` node gets us to `Monkey`. Note that during a breadth first search, the goal test is done when the node is being added to the queue."

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"### Uniform-cost Search"

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"In Uniform-cost Search, we expand the node with the lowest path cost (the cost to reach that node from the start) instead of expanding the shallowest node. Rather than a `FIFO` queue, we use something called a `priority queue` which selects the element with the highest `priority` of all elements in the queue. For our problem, the shortest path between animals has the higher priority; the shortest path has the lowest path cost. Whenever we need to enqueue a node already in the queue, we will update its path cost if the newer path is better. This is a very important step, and it means that the path cost to a node may keep getting better until it is selected for expansion. This is the reason that we do a goal check only when a node is selected for expanion."

]

},

{

"cell_type": "code",

"execution_count": 5,

"metadata": {

"collapsed": false

"outputs": [

{

"data": {

"text/plain": [

"['Dog', 'Bear', 'Monkey']"

]

},

"execution_count": 5,

"metadata": {},

"output_type": "execute_result"

}

],

"ucs_node = uniform_cost_search(monkey_problem)\n",

"ucs_node.solution()"

]

},

{

"cell_type": "markdown",

"metadata": {},

"source": [

"We got the path`['Dog', 'Bear', 'Monkey']` instead of `['Cat', 'Monkey']`. Why? The path cost is lower! We can also see the path cost with the path_cost attribute. Let's compare the path cost of the Breadth first search solution and Uniform cost search solution"

"execution_count": 6,

"collapsed": false

"outputs": [

{

"data": {

"text/plain": [

"(18, 17)"

]

},

"execution_count": 6,

"metadata": {},

"output_type": "execute_result"

}

],

"bfs_node.path_cost, ucs_node.path_cost"

"source": [

"We were right! \n",

"\n",

"The path cost through the `Cat` statue is indeed more than the path cost through `Dog` even though the former passes through two roads compared to the three roads in the `ucs_node` solution."

]

},

{

"cell_type": "markdown",

"metadata": {

"collapsed": true

},

"Let's have a visualisation of Romania map [Figure 3.2] from the book and see how different searching algorithms perform / how frontier expands in each search algorithm for a simple problem to reach 'Bucharest' starting from 'Arad'. This is how the problem is defined:"

]

},

{

"cell_type": "code",

"execution_count": 7,

"metadata": {

"collapsed": false

},

"outputs": [],

"source": [

"romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)"

"execution_count": 8,

"collapsed": false

"outputs": [

{

"name": "stdout",

"output_type": "stream",

"text": [

"{'Rimnicu': (233, 410), 'Hirsova': (534, 350), 'Arad': (91, 492), 'Vaslui': (509, 444), 'Oradea': (131, 571), 'Giurgiu': (375, 270), 'Neamt': (406, 537), 'Fagaras': (305, 449), 'Bucharest': (400, 327), 'Sibiu': (207, 457), 'Urziceni': (456, 350), 'Lugoj': (165, 379), 'Craiova': (253, 288), 'Zerind': (108, 531), 'Iasi': (473, 506), 'Mehadia': (168, 339), 'Pitesti': (320, 368), 'Timisoara': (94, 410), 'Drobeta': (165, 299), 'Eforie': (562, 293)}\n"

]

}

],