Week 4.1 - Genetic Algorithm

x = ga(fun,nvars,A,b) - finds a local minimum x to fun, subject to the linear inequalities A*x ≤ b. ga evaluates the matrix product A*x as if x is transposed (A*x').

x = ga(fun,nvars,A,b,Aeq,beq)- finds a local minimum x to fun, subject to the linear equalities Aeq*x = beq and A*x ≤ b. (Set A=[] and b=[] if no linear inequalities exist.) ga evaluates the matrix product Aeq*x as if x is transposed (Aeq*x').

x = ga(fun,nvars,A,b,Aeq,beq,lb,ub) - defines a set of lower and upper bounds on the design variables, x, so that a solution is found in the range lb ≤ x ≤ ub. (Set Aeq=[] and beq=[] if no linear equalities exist.

x = ga(fun,nvars,A,b,Aeq,beq,lb,ub,nonlcon) - subjects the minimization to the constraints defined in nonlcon. The function nonlcon accepts x and returns vectors C and Ceq, representing the nonlinear inequalities and equalities respectively. ga minimizes the fun such that C(x) ≤ 0 and Ceq(x) = 0. (Set lb=[] and ub=[] if no bounds exist.)

x = ga(fun,nvars,A,b,Aeq,beq,lb,ub,nonlcon,options) - minimizes with the default optimization parameters replaced by values in options. (Set nonlcon=[] if no nonlinear constraints exist.) Create options using optimoptions.

x = ga(fun,nvars,A,b,Aeq,beq,lb,ub,nonlcon,intcon) or x = ga(fun,nvars,A,b,Aeq,beq,lb,ub,nonlcon,intcon,options) - requires that the variables listed in intcon take integer values.

We optimize the given function using three case studies and taking the number of iterations as 50(num_iterations=50):

Syntax Explanation of the code:

linspace(x,y,n) - creates an array of x & y values divided in 'n' number of values.

tic - start the stopwatch timer

toc - stop the stopwatch timer

subplot( m, n, p ) - divides the current figure into an m -by- n grid and creates axes in the position specified by p

plot3 - plots the coordinates in a 3d space

shading interp - shading interp varies the color in each line segment and face by interpolating the colormap index or true color value across the line or face.

The program for GA is as shown below :

Function -

% Creating the stalagmite function

function [F]= stalagmite(input)
x=input(1);
y=input(2);
F1 = [sin(5.1*pi*x+0.5)]^6;
F2 = [sin(5.1*pi*y+0.5)]^6;
F3 = exp(-4*log(2)*((x-0.667)^2/0.64));
F4 = exp(-4*log(2)*((y-0.667)^2/0.64));
F  = -(F1*F2*F3*F4) % we use the negative sign to find the global maxima of the function.

GA Program -

% Optimization Code
clc
clear all
close all

% defining our workspace
x=linspace(0,0.6,150);
y=linspace(0,0.6,150);
[xx,yy]=meshgrid(x,y); % creates a 2d mesh array of x & y values
n=50; % number of iterations have been set to 50

for i= 1:length(xx) 
for j= 1:length(yy)
    input(1)= xx(i,j);
    input(2)= yy(i,j);
    f(i,j)= stalagmite(input);
end
end

% for unbounded inputs
tic
for i = 1:n
    [res,fopt(i)]=ga(@stalagmite,2);
    xopt(i)=res(1);
    yopt(i)=res(2);
end
study_time1=toc;
figure(1)
subplot(2,1,1) 
surf(xx,yy,-f) %generating the surface
shading interp
title 'Statistical Behaviour With Unbounded inputs'
hold on
plot3(xopt,yopt,-fopt,'Marker','o')
subplot(2,1,2)
plot(-fopt)
xlabel('Iterations')
ylabel('F(Max)')

% for bounded inputs
tic
for i = 1:n
    [res,fopt(i)]=ga(@stalagmite,2,[],[],[],[],[0;0],[0.6;0.6]);
    xopt(i)=res(1);
    yopt(i)=res(2);
end
study_time2=toc;
figure(2)
subplot(2,1,1)
surf(xx,yy,-f)
title 'Statistical Behaviour With Bounded inputs'
shading interp
hold on
plot3(xopt,yopt,-fopt,'Marker','o')
subplot(2,1,2)
plot(-fopt)
xlabel('Iterations')
ylabel('F(Max)')

% increasing the number of iterations
tic
options=optimoptions('ga');
options=optimoptions(options,'PopulationSize',250);
for i=1:n
    [res,fopt(i)]=ga(@stalagmite,2,[],[],[],[],[0 0],[0.6 0.6],[],[],options);
    xopt(i)=res(1);
    yopt(i)=res(2);
end
study_time3=toc;
figure(3)
subplot(2,1,1)
surf(xx,yy,-f)
shading interp
title 'Statistical Behaviour with increased no of iterations'
hold on
plot3(xopt,yopt,-fopt,'marker','o')
subplot(2,1,2)
plot(-fopt)
xlabel ('Iterations')
ylabel ('F(Max)')

Results & Case wise Explanation

Case1- Unbounded Values

In the first case, we use unbounded values. The syntax used in the program is explained below :

we have used [x,fval]= ga(fun,nvars)

Where

fun= function

nvars = number of variables

Graph :

As it can be seen from the graph the unbounded values fail to determine the maxima and fall from the stalagmite graph. In this case, the optimum value is calculated every time the code runs thus not giving accurate results.

The runtime observed was - 38.97sec

Case2- Bounded Values

In the second case, we use bounded values. The syntax used in the program is explained below :

x = ga(fun,nvars,A,b,Aeq,beq,lb,ub) - defines a set of lower and upper bounds on the design variables, x, so that a solution is found in the range lb ≤ x ≤ ub. (Set Aeq=[] and beq=[] if no linear equalities exist.

Graph :

As can be seen from the graph by providing the lower and upper bound we observe the randomness of values has been greatly reduced.

The runtime observed was - 24.8431sec

Case3- Increasing the number of iterations

We increase the number of iterations or the population size from 50 to 250.

The syntax used for this is

options=optimoptions('ga');

options=optimoptions(options,'PopulationSize',250);

Graph :

From the above graph, we can clearly see that by increasing the population size we converge the values and find the global maxima.

The runtime observed was - 130.81sec, clearly, the run time is maximum in this case but convergence is better and we can find the global maxima.

Result: The optimization code has been successfully run and different GA methods have been understood.