Skip to content
Related Articles
Open in App
Not now

Related Articles

Introduction to Hill Climbing | Artificial Intelligence

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 17 Jan, 2023
Improve Article
Save Article

Hill Climbing is a heuristic search used for mathematical optimization problems in the field of Artificial Intelligence. 
Given a large set of inputs and a good heuristic function, it tries to find a sufficiently good solution to the problem. This solution may not be the global optimal maximum. 

  • In the above definition, mathematical optimization problems imply that hill-climbing solves the problems where we need to maximize or minimize a given real function by choosing values from the given inputs. Example-Travelling salesman problem where we need to minimize the distance traveled by the salesman.
  • ‘Heuristic search’ means that this search algorithm may not find the optimal solution to the problem. However, it will give a good solution in a reasonable time.
  • A heuristic function is a function that will rank all the possible alternatives at any branching step in the search algorithm based on the available information. It helps the algorithm to select the best route out of possible routes.

Features of Hill Climbing

1. Variant of generating and test algorithm: 

It is a variant of generating and testing algorithms. The generate and test algorithm is as follows : 

  • Generate possible solutions. 
  • Test to see if this is the expected solution. 
  • If the solution has been found quit else go to step 1.

Hence we call Hill climbing a variant of generating and test algorithm as it takes the feedback from the test procedure. Then this feedback is utilized by the generator in deciding the next move in the search space. 

2. Uses the Greedy approach: 

At any point in state space, the search moves in that direction only which optimizes the cost of function with the hope of finding the optimal solution at the end.

Machine-Learning-Course

Types of Hill Climbing

1. Simple Hill climbing:

It examines the neighboring nodes one by one and selects the first neighboring node which optimizes the current cost as the next node. 

Algorithm for Simple Hill climbing :  

  • Evaluate the initial state. If it is a goal state then stop and return success. Otherwise, make the initial state as the current state. 
  • Loop until the solution state is found or there are no new operators present which can be applied to the current state. 
    • Select a state that has not been yet applied to the current state and apply it to produce a new state. 
    • Perform these to evaluate the new state.
      • If the current state is a goal state, then stop and return success. 
      • If it is better than the current state, then make it the current state and proceed further. 
      • If it is not better than the current state, then continue in the loop until a solution is found. 
  • Exit from the function.

2. Steepest-Ascent Hill climbing: 

It first examines all the neighboring nodes and then selects the node closest to the solution state as of the next node. 

Algorithm for Steepest Ascent Hill climbing :

  • Evaluate the initial state. If it is a goal state then stop and return success. Otherwise, make the initial state as the current state. 
  • Repeat these steps until a solution is found or the current state does not change 
    • Select a state that has not been yet applied to the current state.
    • Initialize a new ‘best state’ equal to the current state and apply it to produce a new state.
    • Perform these to evaluate the new state
      • If the current state is a goal state, then stop and return success.
      • If it is better than the best state, then make it the best state else continue the loop with another new state.
    • Make the best state as the current state and go to Step 2 of the second point.
  • Exit from the function.

3. Stochastic hill climbing: 

It does not examine all the neighboring nodes before deciding which node to select. It just selects a neighboring node at random and decides (based on the amount of improvement in that neighbor) whether to move to that neighbor or to examine another. 

  • Evaluate the initial state. If it is a goal state then stop and return success. Otherwise, make the initial state the current state. 
  • Repeat these steps until a solution is found or the current state does not change.
    • Select a state that has not been yet applied to the current state.
    • Apply the successor function to the current state and generate all the neighbor states.
    • Among the generated neighbor states which are better than the current state choose a state randomly (or based on some probability function). 
    • If the chosen state is the goal state, then return success, else make it the current state and repeat step 2 of the second point.
  • Exit from the function.

State Space diagram for Hill Climbing

The state-space diagram is a graphical representation of the set of states our search algorithm can reach vs the value of our objective function(the function which we wish to maximize). 

  • X-axis: denotes the state space ie states or configuration our algorithm may reach. 
  • Y-axis: denotes the values of objective function corresponding to a particular state. 

The best solution will be a state space where the objective function has a maximum value(global maximum). 

objectfuntion

Different regions in the State Space Diagram: 

  • Local maximum: It is a state which is better than its neighboring state however there exists a state which is better than it(global maximum). This state is better because here the value of the objective function is higher than its neighbors. 
     
  • Global maximum: It is the best possible state in the state space diagram. This is because, at this stage, the objective function has the highest value.
  • Plateau/flat local maximum: It is a flat region of state space where neighboring states have the same value.
  • Ridge: It is a region that is higher than its neighbors but itself has a slope. It is a special kind of local maximum.
  • Current state: The region of the state space diagram where we are currently present during the search.
  • Shoulder: It is a plateau that has an uphill edge.

Problems in different regions in Hill climbing

Hill climbing cannot reach the optimal/best state(global maximum) if it enters any of the following regions :  

  • Local maximum: At a local maximum all neighboring states have a value that is worse than the current state. Since hill-climbing uses a greedy approach, it will not move to the worse state and terminate itself. The process will end even though a better solution may exist. 
    To overcome the local maximum problem: Utilize the backtracking technique. Maintain a list of visited states. If the search reaches an undesirable state, it can backtrack to the previous configuration and explore a new path.
  • Plateau: On the plateau, all neighbors have the same value. Hence, it is not possible to select the best direction. 
    To overcome plateaus: Make a big jump. Randomly select a state far away from the current state. Chances are that we will land in a non-plateau region.
  • Ridge: Any point on a ridge can look like a peak because movement in all possible directions is downward. Hence the algorithm stops when it reaches this state. 
    To overcome Ridge: In this kind of obstacle, use two or more rules before testing. It implies moving in several directions at once.

Here is a simple example of hill climbing in Python:

C++




#include <algorithm>
#include <iostream>
#include <vector>
 
// Generates neighbors of x
std::vector<int> generate_neighbors(int x) {
  // TODO: implement this function
}
 
int hill_climbing(int (*f)(int), int x0) {
  int x = x0;  // initial solution
  while (true) {
    std::vector<int> neighbors = generate_neighbors(x);  // generate neighbors of x
    int best_neighbor = *std::max_element(neighbors.begin(), neighbors.end(),
                                          [f](int a, int b) { return f(a) < f(b); });  // find the neighbor with the highest function value
    if (f(best_neighbor) <= f(x))  // if the best neighbor is not better than x, stop
      return x;
    x = best_neighbor;  // otherwise, continue with the best neighbor
  }
}
 
int main() {
  // Example usage
  int x0 = 1;
  int x = hill_climbing([](int x) { return x * x; }, x0);
  std::cout << "Result: " << x << std::endl;
  return 0;
}


Python3




def hill_climbing(f, x0):
  x = x0  # initial solution
  while True:
    neighbors = generate_neighbors(x)  # generate neighbors of x
    best_neighbor = max(neighbors, key=f)  # find the neighbor with the highest function value
    if f(best_neighbor) <= f(x):  # if the best neighbor is not better than x, stop
      return x
    x = best_neighbor  # otherwise, continue with the best neighbor


Output

 

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!