LAB Manual Part A: Experiment No.03

Terna Engineering College
Computer Engineering Department

Program: Sem VI
Course: Artificial Intelligence
Faculty: Rohini Patil
LAB Manual
PART A
Experiment No.03
A.1 Aim: To Implement informed A* search methods using C /python/Java.
A.2 Prerequisite: Data Structure, Searching Techniques
A.3 Outcome:
After successful completion of this experiment students
will be able to
 Ability to analyse the local and global impact of computing in searching techniques.
 Understand, identify, analyse and design the problem, implement and validate the
solution for the A* search method.
 Ability to applying knowledge of computing in search technique areas.
Tools Required: C /Java
A.4 Theory:
An informed search strategy-one that uses problem-specific knowledge-can find solutions
more efficiently.A key component of these algorithms is a heuristic function h(n).
h(n) = estimated cost of the cheapest path from node n to a goal node.Admissible /heuristic
never over estimated i.e. h(n)≤ Actual cost.
For example, Distance between two nodes(cities)=> straight line distance and for 8-puzzel
problem- Admissible heuristic can be number of misplaced tiles h(n)= 8.
A* Search technique:
It is informed search technique. It uses additional information beyond problem formulation
and tree. Search is based on Evaluation function f(n). Evaluation function is based on both
heuristic function h(n) and g(n).
f(n)=g(n) + h(n)
It uses two queues for its implementation: open, close Queue. Open queue is a priority queue
which is arranged in ascending order of f(n)
Algorithm:
1. Create a single member queue comprising of Root node
2. If FIRST member of queue is goal then goto step 5
3. If first member of queue is not goal then remove it from queue and add to
close queue.
4. Consider its children if any, and add them to queue in ascending order of
evaluation function f(n).
5. If queue is not empty then goto step 2.
6. If queue is empty then goto step 6
7. Print ‘success’ and stop
8. Print ‘failure’ and stop.
Performance Comparison:
 Completeness: yes
 Optimality: yes
Time complexity :o(bd)
Limitation:
 It generate same node again and again
 Large Memory is required
Observation
Although A*generate many nodes it never uses those nodes for which f(n)> c* where c* is
optimum cost.
Consider an example as below

OPEN/FRINGE CLOSE
[A] [ ]
[C,B] [A]
[D,B,E,A] [A,C]
[F,E,B,C,A] [A,C,D]
[G,E,B,C,A,D] [A,C,D,F]
SUCCESS
Node A:
f(B)=g(B) + h(B)=3+5=8
f(C) =g(C) + h(C)=1 + 6=7
Node C:
f(A) = g(A) + h(A)=2+7=10
f(D) = g(D) + h(D)=3+4=7
f(E) = g(E) + h(E)=7+1=8
Node D:
f(F) = g(F) + h(F)=6+1=7
f(C) = g(C) + h(C)= 5+6=11
f(B) = g(B) + h(B)=4+5=9
Node F:
f(E) = g(E) + h(E)=7+1=8
f(D) = g(D) + h(D)= 9+4=13
f(G) = g(G) + h(G)=7+0=7
Final path: A  C  DF  G

Total cost= 7
PART B
(PART B : TO BE COMPLETED BY STUDENTS)
(Students must submit the soft copy as per following segments within
two hours of the practical. The soft copy must be uploaded on the
Blackboard or emailed to the concerned lab in charge faculties at the
end of the practical in case the there is no Black board access available)
Roll No. 62 Name: Jerrin Jiju Chacko

Class : TE-A Comps Batch : A4
Date of Experiment: 28/01/2022 Date of Submission: 04/02/2022
Grade :
B.1 Document created by the student:
(Write the answers to the questions given in section 4 during the 2
hours of practical in the lab here)
from __future__ import print_function
import matplotlib.pyplot as plt
class AStarGraph(object):
def __init__(self):
self.barriers = []
self.barriers.append([(2,4),(2,5),(2,6),(3,6),(4,6),(5,6),(5,5),(5,4),(5,3),(5,2),
(4,2),(3,2)])
def heuristic(self, start, goal):
D=1
D2 = 1
dx = abs(start[0] - goal[0])
dy = abs(start[1] - goal[1])
return D * (dx + dy) + (D2 - 2 * D) * min(dx, dy)
def get_vertex_neighbours(self, pos):
n = []
for dx, dy in [(1,0),(-1,0),(0,1),(0,-1),(1,1),(-1,1),(1,-1),(-1,-1)]:
x2 = pos[0] + dx
y2 = pos[1] + dy
if x2 < 0 or x2 > 7 or y2 < 0 or y2 > 7:
continue
n.append((x2, y2))
return n
def move_cost(self, a, b):
for barrier in self.barriers:
if b in barrier:
return 100
def AStarSearch(start, end, graph):
G = {}
F = {}
G[start] = 0
F[start] = graph.heuristic(start, end)
closedVertices = set()
openVertices = set([start])
cameFrom = {}
while len(openVertices) > 0:
current = None
currentFscore = None
for pos in openVertices:
if current is None or F[pos] < currentFscore:
currentFscore = F[pos]
current = pos
if current == end:
path = [current]
while current in cameFrom:
current = cameFrom[current]
path.append(current)
path.reverse()
return path, F[end]
openVertices.remove(current)
closedVertices.add(current)
for neighbour in graph.get_vertex_neighbours(current):
if neighbour in closedVertices:
continue
candidateG = G[current] + graph.move_cost(current, neighbour)
if neighbour not in openVertices:
openVertices.add(neighbour)
elif candidateG >= G[neighbour]:
continue
cameFrom[neighbour] = current
G[neighbour] = candidateG
H = graph.heuristic(neighbour, end)
F[neighbour] = G[neighbour] + H
raise RuntimeError("A* failed to find a solution")
if __name__=="__main__":
graph = AStarGraph()
result, cost = AStarSearch((0,0), (7,7), graph)
print ("route", result)
print ("cost", cost)

B.2 Observations and learning:
A-star (also referred to as A*) is a search algorithm to find the shortest path between nodes or
graphs. It is an informed search algorithm, as it uses information about path cost and also
uses heuristics to find the solution. A major drawback of the algorithm is its space and time
complexity. It takes a large amount of space to store all possible paths and a lot of time to
find them.
B.3 Conclusion:
In this experiment we Implement informed A* search methods using Python.
B.4 Question of Curiosity:

Q1) Apply A* algorithm in the following example and find the cost
Ans: f = accumulated path cost + heuristic

QUEUE = path containing root
QUEUE: <S>
QUEUE: <SB,SA>
QUEUE: <SA,SBC,SBG,SBA>
QUEUE: <SBC,SBG,SAB>
QUEUE: <SBCG,SBG>
QUEUE: <SBCG>
Q2) What is the other name of informed search strategy?

a. Simple search
b. heuristic search
c. online search
d. none of the above
Ans: b
Explanation: A key point of informed search strategy is heuristic function, So it is called as
heuristic function.

LAB Manual Part A: Experiment No.03

Uploaded by

Copyright:

Available Formats

LAB Manual Part A: Experiment No.03

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

LAB Manual Part A: Experiment No.03

Uploaded by

Copyright:

Available Formats

Terna Engineering College

Computer Engineering Department

Course: Artificial Intelligence

Faculty: Rohini Patil

Tools Required: C /Java

Consider an example as below

Final path: A  C  DF  G

Roll No. 62 Name: Jerrin Jiju Chacko

from __future__ import print_function

import matplotlib.pyplot as plt

def heuristic(self, start, goal):

return D * (dx + dy) + (D2 - 2 * D) * min(dx, dy)

def get_vertex_neighbours(self, pos):

for dx, dy in [(1,0),(-1,0),(0,1),(0,-1),(1,1),(-1,1),(1,-1),(-1,-1)]:

if x2 < 0 or x2 > 7 or y2 < 0 or y2 > 7:

def move_cost(self, a, b):

for barrier in self.barriers:

def AStarSearch(start, end, graph):

F[start] = graph.heuristic(start, end)

while len(openVertices) > 0:

for pos in openVertices:

if current is None or F[pos] < currentFscore:

while current in cameFrom:

return path, F[end]

for neighbour in graph.get_vertex_neighbours(current):

candidateG = G[current] + graph.move_cost(current, neighbour)

if neighbour not in openVertices:

elif candidateG >= G[neighbour]:

raise RuntimeError("A* failed to find a solution")

result, cost = AStarSearch((0,0), (7,7), graph)

print ("route", result)

print ("cost", cost)

B.4 Question of Curiosity:

Ans: f = accumulated path cost + heuristic

Q2) What is the other name of informed search strategy?

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

from future import print_function