Scribd
Upload
66 views6 pages

Assignment - 05: Shivam Kamlesh Yadav BEIT-B4 77

The document describes the Hill Climbing algorithm. It defines Hill Climbing as a local search technique that continuously moves in the direction of increasing value to find the optimal solution. It then discusses key aspects of Hill Climbing like the generate and test approach, greedy nature with no backtracking, and types including simple, steepest ascent, and stochastic Hill Climbing. The document also covers potential problems like local maxima and plateaus, and provides solutions like backtracking or random moves. Finally, it includes pseudocode to implement simple Hill Climbing to minimize the distance traveled between points.

Uploaded by

Game Twitcher
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
66 views6 pages

Assignment - 05: Shivam Kamlesh Yadav BEIT-B4 77

The document describes the Hill Climbing algorithm. It defines Hill Climbing as a local search technique that continuously moves in the direction of increasing value to find the optimal solution. It then discusses key aspects of Hill Climbing like the generate and test approach, greedy nature with no backtracking, and types including simple, steepest ascent, and stochastic Hill Climbing. The document also covers potential problems like local maxima and plateaus, and provides solutions like backtracking or random moves. Finally, it includes pseudocode to implement simple Hill Climbing to minimize the distance traveled between points.

Uploaded by

Game Twitcher
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

ASSIGNMENT - 05

Name: ​Shivam Kamlesh Yadav


Class: ​BEIT-B4
Roll No.: ​77
D​.O.P :
D.O.S :
Grade :
Sign :

Aim: ​Implementation of Hill Climbing Algorithm.

Theory:

Hill climbing: ​It is one of the local search techniques.Hill climbing algorithms is a local
search algorithm which continuously moves in the direction of increasing elevation/value to
find the peak of the mountain or best solution to the problem. It terminates when it reaches a
peak value where no neighbor has a higher value.
Hill climbing algorithm is a technique which is used for optimizing mathematical problems. One
of the widely discussed examples of Hill climbing algorithms is the Traveling-salesman Problem
in which we need to minimize the distance traveled by the salesman.
It is also called greedy local search as it only looks to its good immediate neighbor state and
not beyond that.
A node of hill climbing algorithm has two components which are state and
value. Hill Climbing is mostly used when a good heuristic is available.
In this algorithm, we don't need to maintain and handle the search tree or graph as it only keeps
a single current state.

Features of Hill Climbing:


Generate and Test variant: ​Hill Climbing is the variant of Generate and Test method. The
Generate and Test method produces feedback which helps to decide which direction to move in
the search space.
Greedy approach: ​Hill-climbing algorithm search moves in the direction which optimizes
the cost.
No backtracking: ​It does not backtrack the search space, as it does not remember the previous
states.

State-space Diagram for Hill Climbing:


The state-space landscape is a graphical representation of the hill-climbing algorithm which is
showing a graph between various states of algorithm and Objective function/Cost. On Y-axis
we
have taken the function which can be an objective function or cost function, and state-space on
the x-axis. If the function on Y-axis is cost then, the goal of search is to find the global minimum
and local minimum. If the function of the Y-axis is Objective function, then the goal of the
search is to find the global maximum and local maximum.

Different regions in the state space landscape:


Local Maximum: ​Local maximum is a state which is better than its neighboring states, but
there is also another state which is higher than it.
Global Maximum: ​Global maximum is the best possible state of state space landscape. It
has the highest value of objective function.
Current state: ​It is a state in a landscape diagram where an agent is currently present.
Flat local maximum: ​It is a flat space in the landscape where all the neighboring states
of current states have the same value.
Shoulder: ​It is a plateau region which has an uphill edge.

Types of Hill Climbing Algorithm:


● ​Simple hill Climbing
● ​Steepest-Ascent hill-climbing
● ​Stochastic hill Climbing

Simple Hill Climbing:


Simple hill climbing is the simplest way to implement a hill climbing algorithm. It only
evaluates the neighbor node state at a time and selects the first one which optimizes current cost
and set it as a current state. It only checks it's one successor state, and if it finds better than the
current state, then move else be in the same state. This algorithm has the following features: Less
time consuming
Less optimal solution and the solution is not guaranteed

Algorithm for Simple Hill Climbing:


Step 1: Evaluate the initial state, if it is goal state then return success and
Stop. Step 2: Loop Until a solution is found or there is no new operator left to
apply. Step 3: Select and apply an operator to the current state.
Step 4: Check new state:
If it is goal state, then return success and quit.
Else if it is better than the current state then assign new state as a current
state. Else if not better than the current state, then return to step2.
Step 5: Exit.
Steepest-Ascent hill climbing:
The steepest-Ascent algorithm is a variation of simple hill climbing algorithm. This algorithm
examines all the neighboring nodes of the current state and selects one neighbor node which is
closest to the goal state. This algorithm consumes more time as it searches for multiple
neighbors

Algorithm for Steepest-Ascent hill climbing:


Step 1: Evaluate the initial state, if it is goal state then return success and stop, else make
current state as initial state.
Step 2: Loop until a solution is found or the current state does not change. Let
SUCC be a state such that any successor of the current state will be better than it.
For each operator that applies to the current state:
Apply the new operator and generate a new state.
Evaluate the new state.
If it is goal state, then return it and quit, else compare it to the SUCC.
If it is better than SUCC, then set new state as SUCC.
If the SUCC is better than the current state, then set the current state to
SUCC. Step 3: Exit.

Stochastic hill climbing:


Stochastic hill climbing does not examine for all its neighbor before moving. Rather, this search
algorithm selects one neighbor node at random and decides whether to choose it as a current
state or examine another state.

Problems in Hill Climbing Algorithm:


Local Maximum​: A local maximum is a peak state in the landscape which is better than each
of its neighboring states, but there is another state also present which is higher than the local
maximum.
Solution: ​Backtracking technique can be a solution of the local maximum in state space
landscape. Create a list of the promising path so that the algorithm can backtrack the
search space and explore other paths as well.

Plateau: ​A plateau is the flat area of the search space in which all the neighboring states of the
current state contains the same value, because of this algorithm does not find any best direction
to move. A hill-climbing search might be lost in the plateau area.
Solution: The solution for the plateau is to take big steps or very little steps while searching,
to solve the problem. Randomly select a state which is far away from the current state so it is
possible that the algorithm could find non-plateau region.

Ridges: ​A ridge is a special form of the local maximum. It has an area which is higher than
its surrounding areas, but itself has a slope, and cannot be reached in a single move.
Solution: ​With the use of bidirectional search, or by moving in different directions, we
can improve this problem.

Algorithm:
Step 1: Evaluate the Initial state. If the first state is a goal state then stop and return success.
Else, make the Initial state as Current state.
Step 2: Loop until the Solution state is found or if there are no new operators present which
can be applied to Current state.
Select a state that has not yet been applied to the Current state and then apply it to produce
a New state.
Perform these steps to evaluate New state: i. If the Current state is the Goal state, then Stop and
return success. ii. If the New state is better than the Current state, then make it the Current state
and proceed further. iii. If the New state is not better than the current state, then continue the
loop until a solution is found.
Step 3: Exit.

Program:
import math

increment = 0.1
startingPoint = [1, 1]
point1 = [1,5]
point2 = [6,4]
point3 = [5,2]
point4 = [2,1]

def distance(x1, y1, x2, y2):


dist = math.pow(x2-x1, 2) + math.pow(y2-y1, 2)
return dist

def sumOfDistances(x1, y1, px1, py1, px2, py2, px3, py3, px4, py4):
d1 = distance(x1, y1, px1, py1)
d2 = distance(x1, y1, px2, py2)
d3 = distance(x1, y1, px3, py3)
d4 = distance(x1, y1, px4, py4)

return d1 + d2 + d3 + d4
def newDistance(x1, y1, point1, point2, point3, point4):
d1 = [x1, y1]
d1temp = sumOfDistances(x1, y1, point1[0],point1[1], point2[0],point2[1],
point3[0],point3[1], point4[0],point4[1] )
d1.append(d1temp)
return d1

minDistance = sumOfDistances(startingPoint[0], startingPoint[1],


point1[0],point1[1], point2[0],point2[1],
point3[0],point3[1], point4[0],point4[1] )
flag = True

def newPoints(minimum, d1, d2, d3, d4):


if d1[2] == minimum:
return [d1[0], d1[1]]
elif d2[2] == minimum:
return [d2[0], d2[1]]
elif d3[2] == minimum:
return [d3[0], d3[1]]
elif d4[2] == minimum:
return [d4[0], d4[1]]

i=1
while flag:
d1 = newDistance(startingPoint[0]+increment, startingPoint[1], point1, point2, point3, point4)
d2 = newDistance(startingPoint[0]-increment, startingPoint[1], point1, point2, point3, point4)
d3 = newDistance(startingPoint[0], startingPoint[1]+increment, point1, point2, point3, point4)
d4 = newDistance(startingPoint[0], startingPoint[1]-increment, point1, point2, point3, point4)
print (i,' ', round(startingPoint[0], 2), round(startingPoint[1], 2))
minimum = min(d1[2], d2[2], d3[2], d4[2])
if minimum < minDistance:
startingPoint = newPoints(minimum, d1, d2, d3, d4)
minDistance = minimum
#print i,' ', round(startingPoint[0], 2), round(startingPoint[1], 2)
i+=1
else:
flag = False
Output:
Conclusion: ​Hence we have successfully studied and implemented Hill Climbing
Algorithm.

You might also like