GLOBAL MAXIMA BY OPTIMIZING A STALAGMITE FUNCTION USING GENETIC ALGORITHM IN MATLAB

1. Selection rules select the individuals, called parents, that contribute to the population at the next generation.

2. Crossover rules combine two parents to form children for the next generation.

3. Mutation rules apply random changes to individual parents to form children.

2.1. The syntax for Genetic Algorithm: -

The following are the syntaxes used for applying the 'ga'. The basic attribute for the syntaxes is that it solves the minimum for any problem. According to the environment, the syntax is chosen.

2.2. Working Methodology of the Genetic Algorithm: -

The following outline summarizes how the genetic algorithm works:

2.3. The Stopping Criteria for the Genetic Algorithm: -

The genetic algorithm uses the following conditions to determine when to stop:

The algorithm stops as soon as anyone of these conditions is met.

III. MATLAB PROGRAM

A. Program for creating the Stalagmite Function

% A program to create the Stalagmite Function

function [S] = stalagmite(input_val)
x = input_val(1);
y = input_val(2);

T1 = (sin(5.1*pi*x + 0.5))^6;
T2 = (sin(5.1*pi*y + 0.5))^6;
T3 = exp(-4*log(2)*((x - 0.0667)^2)/0.64);
T4 = exp(-4*log(2)*((y - 0.0667)^2)/0.64);

S = -(T1*T2*T3*T4); 

end 

A.1. Steps for the above program: -

1. For creating the function program, the keyword 'function' along with the output variable in brackets is used to initiate the code. This is followed by providing the desired syntax (for our case - stalagmite) with the necessary input vectors under parenthesis.
2. Since the input vector consists of two arrays of different values, they are assigned to the respective positions.
3. As seen from the formula of the Stalagmite Function, the expression is broken into four terms for the ease of purpose.
4. Finally, the output variable is given a product of all four terms. The value of S is negative so that the formulation has evaluated for the Global Maxima. The function is ended after this.

A.2. The result from the above program: -

The Stalagmite Figure

The figure above represents the structure of a set of Stalagmites with several Local maxima and one Global maximum. This result is obtained once it is run through the following code.

The program depicted by A. is a functional program that has to be executed in a different program by calling the same function (as seen in the 'for' loop above). This is done to show how the Stalagmite Function works and what we are trying to deal with. This step is not an elegant part of the procedure and hence not included in section A.1.

A.3. Errors from the above program: -

No intricate errors were encountered while running the above program.

B. Program for evaluating the Global Maxima of the Stalagmite Function using GA

% A program to optimize the Stalagmite function by calculating the Global Maxima

clear all
close all
clc

%% Input vectors
x       = linspace(0,0.6,150); % Creating uniform vectors
y       = linspace(0,0.6,150);
i_num   = 50;                  % Number of iterations to compute
[xx,yy] = meshgrid(x,y);       % Creating a 2D array
    
% Assigning Input Values to the Function
for i = 1:length(xx)
    for j = 1:length(yy)
        input_val(1) = xx(i,j);
        input_val(2) = yy(i,j);
        S(i,j) = stalagmite(input_val);
    end
end 

%% STUDY #1 - Statistical Behavior under Unbounded Conditions

tic
% Evaluating the function using GA
for k = 1:i_num
    [inputs_1, fopt_1(k)] = ga(@stalagmite, 2);
    xopt_1(k) = inputs_1(1);
    yopt_1(k) = inputs_1(2); 
end
study1_time = toc;

% Plot commands for STUDY #1
figure(1)
subplot(2,1,1)
hold on 
surfc(xx,yy,S)
shading interp
plot3(xopt_1,yopt_1,fopt_1,'marker','o','markersize',5,'markerfacecolor','r')
xlabel('X Values')
ylabel('Y Values')
title('Statistical Behavior under Unbounded Conditions')
subplot(2,1,2)
plot(fopt_1)
xlabel('Iterations')
ylabel('Function Value at the Solution')


%% STUDY #2 - Statistical Behavior under Upper and Lower Bounds

tic
% Evaluating the function using GA
for k = 1:i_num
  [inputs_2, fopt_2(k)] = ga(@stalagmite,2,[],[],[],[],[0;0],[1;1]);
  xopt_2(k) = inputs_2(1);
  yopt_2(k) = inputs_2(2);
end
study2_time = toc;

% Plot commands for STUDY #2
figure(2)
subplot(2,1,1)
hold on
surfc(xx,yy,S)
shading interp
plot3(xopt_2,yopt_2,fopt_2,'marker','o','markersize',5,'markerfacecolor','r')
xlabel('X Values')
ylabel('Y Values')
title('Statistical Behavior under Bounded Conditions')
subplot(2,1,2)
plot(fopt_2)
xlabel('Iterations')
ylabel('Function Value at the Solution')
    

%% STUDY #3 - Statistical Behavior under Increasing Population
options = optimoptions('ga');
options = optimoptions(options,'PopulationSize', 220);

tic
% Evaluating the function using GA
for k = 1:i_num
  [inputs_3, fopt_3(k)] = ga(@stalagmite,2,[],[],[],[],[0;0],[1;1],[],[],options);
  xopt_3(k) = inputs_3(1);
  yopt_3(k) = inputs_3(2);
end
study3_time = toc;

% Plot commands for STUDY #3
figure(3)
subplot(2,1,1)
hold on
surfc(xx,yy,S)
shading interp
plot3(xopt_3,yopt_3,fopt_3,'marker','o','markersize',5,'markerfacecolor','r')
xlabel('X Values')
ylabel('Y Values')
title('Statistical Behavior with Higher Population Size')
subplot(2,1,2)
plot(fopt_3)
xlabel('Iterations')
ylabel('Function Value at the Solution')

%% Assembling Study Times into a single array
Study_Times = [study1_time study2_time study3_time] % Array for time taken by each study

%% Determining the Global Maxima Coordinates
X = min(xopt_3);
Y = min(yopt_3);
Z = min(fopt_3);
Global_Maxima = [X Y Z]

B.1. Steps for the above program: -

1. The program is commenced with the basic 'clear all','close all','clc' commands.
2. The input vectors are provided using 'linspace' command for equal intervals. Also, the number of iterations was specified and the inputs are converted into a 2D array using the 'meshgrid' command.
3. The inputs are further assigned as the functional values for the stalagmite function using the 'for' loop. ◈ STUDY #1 - Statistical Behavior under Unbounded Conditions
4. The first study is initiated with the 'tic' command to start the timer. A 'for' loop is opened ranging from 1 to the length of the number of iterations.
5. This study engages the genetic algorithm without any restriction or bounds. This means that the GA will freely choose the population to reproduce and mutate. Under the loop, evaluation of the Stalagmite function is done by calling the GA using the syntax as seen in the program. Here, the input array and output array are given followed by the initiation of GA for the function having two variables. The syntax can be understood from point 2.1 stated above.
6. Under the same loop, the variables for input arrays are provided. This has to be done since the input arrays have to be known throughout the formulation of the loop. The loop is ended from here.
7. The timer is ended using the 'toc' command and noted as a constant term.
8. Plot commands are further given. Two different subplots are created. In the first one, the 'surfc' function is used to plot the stalagmite and 'plot3' command is used to plot the points evaluated by the GA. The second subplot is graphed for the output values for the stalagmite function that provides a reference. All the necessary titles and labels are given. ◈ STUDY #2 - Statistical Behavior under Upper and Lower Bounds
9. For the second study, all the steps are the same as the first study except the evaluation step. As observed in the code, the syntax for the GA is different. Here the GA is provided with an upper limit as well as a lower limit for finding the minimum under the population. The variables for this study are altered accordingly.
10. The plot commands for this study remain identical to the previous study. Only the variables and titles are changed per the current study. ◈ STUDY #3 - Statistical Behavior under Increasing Population
11. For the third study, the procedure is a tad bit different. Here, the population size for iteration has to bee increased to get an accurate answer. To increase the iterations, the 'optimoption' function is used to increase population size to the desired value. We take 220 for our purpose. The syntax for GA that has to be used can be seen in the code. The 'option' function is integrated into the evaluation loop. The rest of the steps are pretty identical to the previous study. Necessary changes are made to all the variables for this study.
12. The plot commands remain the same for this study as well except for the variation in the variables.
13. Finally, the total evaluation times for each study are assembled in an array for comparison. Also, the minimum values from the output arrays are picked to display the coordinates of Global Maxima. This was done on a trial basis since the coordinate of the global maxima is obtained by getting the least values from the output values. This can be understood by examining the results.

B.2. Results from the above program: -

1. STUDY #1 - Statistical Behavior under Unbounded Conditions

The above plot is the result of our first study where the GA is run without any restrictions and was free to choose the population for iteration. As a result, the points that were chosen by the algorithm for evaluation can be seen in the first subplot marked by red-colored dots. It is visible that the points are all over the place and this study fails to predict the coordinates for Global Maxima.

2. STUDY #2 - Statistical Behavior under Upper and Lower Bounds

The above-mentioned plot shows much less variation and it looks cleaner. The algorithm is now able to determine the position of the peaks of the function. This happens as a result of providing bounds to the GA which reduces the variation of the values of the function. Although this method provides us with the points of various maxima, it turns out to be futile if we want to find a single Global Maxima. At least this method doesn't change the result on carrying out multiple iterations.

3. STUDY #3 - Statistical Behavior under Increasing Population