Summer Internship report

on

Evaluation Of Optimization Techniques for Test

Functions
Under the Guidance of
Dr. S N Omkar , Chief Research Scientist, Aerospace Engineering, Indian Institute Of Science , Bangalore, India

Dr. Radhakant Padhi, Associate Professor, Aerospace Engineering, Indian Institute Of Science , Bangalore, India
Mr. Ashoka Vanjare, Project assistant, Indian institute of science, Bangalore

At

Indian Institute Of Science (IISc), Bangalore, India

Submitted by

SUMAN MISHRA
Roll No : 113ID0331

Bachelor of Technology
in
Department of Industrial Design
National Institute Of Technology Rourkela
Odisha, India

18 May’15 - 17 July’15
Preface
Acknowledgements
Abstract
INTRODUCTION
 TEST FUNCTIONS

1. Sphere function – It

f (x)  i 0 xi2
n

Graph of Sphere for x,y with range (-50,50)

80

60
sphere function

40

20

0
50
50
0
0

Y -50 -50
X

2. Rosenbrock function:

f (x)  i 0 [100( xi 1  xi2 )2  (x i  1)2 ]

n 1
 Rosenbrock function

1500

1000

500

0
1.5
1
2
0.5
1
0
-0.5 0
-1 -1
Y Range(0,1) -1.5 -2 X Range(-1.5,1.5)

3. Rastrigin function:

f (x)  An  i 0 [ xi2  ACos(2 Xi )]

n

50

40

30

20

10

0
2
1 2
0 1
0
-1 -1
-2 -2

4. Griewank function:

n
xi
 i 0 xi2   cos(
n
f (x)  1  1
4000 )
i 1 i
 5

0
100
80
60 100
80
40
60
20 40
20
0 0

5. Schaffer function:
∈

sin 2 ( x 2  y 2 )  0.5
f (x, y)  0.5 
(0  0.001(x 2  y 2 )) 2
Schaffer function

0.8

0.6

0.4

0.2

0
2
1 2
0 1
0
-1 -1
x2 -2 -2
x1
6. Schwefel function:

f (x)  418.9829d  i 0 xi sin( xi

d

schwefel function

4500

4400

4300

4200

4100

4000

3900
200
100 200
0 100
0
-100 -100
-200 -200

7. Ackley’s function:

f (x, y)  20 exp(0.2 0.5( x 2  y 2 ))  exp(0.5(cos(2 y )))  e 20




clear,clc,close all

% The network has tanh hidden

% neurons and a linear output neuron.
% and applied for predicting y=f(x)
%
% adjust the learning rate with the slider

%% Initializing
hidden_neurons = 4;
epochs = 300;
N=3;

% ------- load in the data -------

X1 = [1,2,3]; %input
X2 = [4,5,6]; %input

Y_train = h(X1);
Y1_train= h(X2);

train_inp = [X1'; X2']; %setting input

train_out = [Y_train'; Y1_train']; %seting Out put

% X = linspace(0,1,N);
% [X1,X2]=meshgrid(X);
% Z=(X1.^2+X2.^2-1);
% plot3(X1,X2,Z)
% train_inp=[X1(:);X2(:)];
% train_out=[Z(:);Z(:)];
% Y_train =sin(2*pi*X1).*sin(2*pi*X2); %satisfy output%f(X1)*f(X2);%

% check same number of patterns in each

if size(train_inp,1) ~= size(train_out,1)
disp('ERROR: data mismatch')
return
end

%standardise the data to mean=0 and standard deviation=1

%inputs
mu_inp = mean(train_inp);
sigma_inp = std(train_inp);
train_inp = (train_inp(:,:) - mu_inp(:,1)) / sigma_inp(:,1);
%outputs
train_out = train_out';
mu_out = mean(train_out);
sigma_out = std(train_out);
train_out = (train_out(:,:) - mu_out(:,1)) / sigma_out(:,1);
train_out = train_out';

%read how many patterns

patterns = size(train_inp,1);

%add a bias as an input

bias = ones(patterns,1);
train_inp = [train_inp bias];

%read how many inputs

inputs = size(train_inp,2);

%---------- data loaded ------------

%--------- add some control buttons ---------

%add button for early stopping
hstop = uicontrol('Style','PushButton','String','Stop', 'Position', [5 5
70 20],'callback','earlystop = 1;');
earlystop = 0;

%add button for resetting weights

hreset = uicontrol('Style','PushButton','String','Reset Wts', 'Position',
get(hstop,'position')+[75 0 0 0],'callback','reset = 1;');
reset = 0;

%add slider to adjust the learning rate

hlr =
uicontrol('Style','slider','value',.1,'Min',.01,'Max',1,'SliderStep',[0.01
0.1],'Position', get(hreset,'position')+[75 0 100 0]);

% ---------- set weights -----------------

%set initial random weights
weight_input_hidden = ([0.2,1.3,0.4,2.5;3.5,0.6,0.7,1.8] - 0.5)/N;
weight_hidden_output = ([0,0.6,0.3,0.9] - 0.5)/N;

%% Learining

%do a number of epochs

for iter = 1:epochs

%get the learning rate from the slider

alr = get(hlr,'value');
blr = alr / N;

%loop through the patterns, selecting randomly

for j = 1:patterns
 %select a random pattern
patnum = round((rand * patterns) + 0.5);
if patnum > patterns
patnum = patterns;
elseif patnum < 1
patnum = 1;
end

%set the current pattern

this_pat = train_inp(patnum,:);
act = train_out(patnum,1);

%calculate the current error for this pattern

hval = (tanh(this_pat*weight_input_hidden))';
pred = hval'*weight_hidden_output';
error = pred - act;

% adjust weight hidden - output

delta_HO = error.*blr .*hval;
weight_hidden_output = weight_hidden_output - delta_HO';

% adjust the weights input - hidden

delta_IH= alr.*error.*weight_hidden_output'.*(1-
(hval.^2))*this_pat;
weight_input_hidden = weight_input_hidden - delta_IH';

end
% -- another epoch finished

%plot overall network error at end of each epoch

pred = weight_hidden_output*tanh(train_inp*weight_input_hidden)';
error = pred' - train_out;
err(iter) = (sum(error.^2))^0.5;

figure(1);
plot(err)
xlabel('no of iteration')
ylabel('MSE')

%reset weights if requested

if reset
weight_input_hidden = ([1,2,3,4;5,6,7,8] - 0.5)/N;
weight_hidden_output = ([1,2,3,4] - 0.5)/N;
fprintf('weights reaset after %d epochs\n',iter);
reset = 0;
end

%stop if requested
if earlystop
fprintf('stopped at epoch: %d\n',iter);
break
end
 %stop if error is small
if err(iter) < 0.001
fprintf('converged at epoch: %d\n',iter);
break
end

end

%% Testing
X3 = [0.2,0.5,0.8]';
X4 = [0.3,0.6,0.7]';

train_test = [X3; X4];

mu_test = mean(train_test);
sigma_test = std(train_test);
train_test = (train_test(:,:) - mu_test(:,1)) / sigma_test(:,1);
train_test = [train_test bias];

pred = weight_hidden_output*tanh(train_test*weight_input_hidden)';

%% Finish
fprintf('state after %d epochs\n',iter);
a = (train_out* sigma_out(:,1)) + mu_out(:,1);
b = (pred'* sigma_out(:,1)) + mu_out(:,1);
act_pred_err = [a b b-a] %display actual,predicted & error

figure,plot3(X3,X4,act_pred_err((1:(size(train_inp,1)/2)),2),'color','red'
,'linewidth',2)
grid on,title(' Approximatly result (using Neural Networks');
figure,plot3(X1,X2,Y_train, 'color','green','linewidth',2)
grid on,title(' Y = Orginal result');
Minimum error = 0.0370.
Observation:
Taxonomy:

Inspiration:

Strategy:

Procedure

Heuristics:
 σ

%clc
clear all;
close all;
epochs=300;

n1 = [1,2,3];
x1 = f(n1);

n2 = [4,5,6];
x2 = f(n2);

xn_train = n1;
dn_train = x1;
xn_test = n2;
dn_test = x2;

%---------------------------------------------------
switch 1
case 1

% Functional Optimization Of Non-linear Function using Radial Basis

Function

P = xn_train;
T = dn_train;
spread = 50;
net = newrbe(P,T,spread);

case 2

P = xn_train;
T = dn_train;
goal = 1e-12;
spread = 50;
MN = size(xn_train,2);
DF = 1;
net = newrb(P,T,goal,spread,MN,DF);
case 3

P = xn_train;
T = dn_train;
spread = 0.5;
net = newgrnn(P,T,spread);

end
for iter =1:epochs
err1 = sum((dn_train-sim(net,xn_train)).^2);

X = sim(net,xn_test);

err2(iter) = (sum((dn_test-X).^2))^0.5 ;

figure(1);
plot(err2)
xlabel('no of iteration')
ylabel('MSE')
end

%---------------------------------------------------

figure,plot(1:length(n2),x2,'r+:',1:length(n2),X,'bo:')
title('figure');
xlabel('testing output')
ylabel('processed output')
Error1(difference b/w predicted and training data)=1.2037*exp(-24)
Error2(difference b/w predicted and testing data) =42.3675

Error1(difference b/w predicted and training data)= 3.1554*exp(-30)

Error2(difference b/w predicted and testing data) = 98.2503.
In

Error1(difference b/w predicted and training data)=7.5102*exp(-27)

Error2(difference b/w predicted and testing data) = 171.5458
In

Error1(difference b/w predicted and training data)=1.9646*exp(-24)

Error2(difference b/w predicted and testing data) = 15.5036.
TEACHING LEARNING BASED OPTIMIZATION
(TLBO)
Taxonomy:

Inspiration:

Strategy:

Procedure:
Heuristics:
1.

2.
3.

4.
Code Listing:
clear all
clc
stu_num= 3; % the number of students
subj_num=3; % the number of design variables or no of subjects which
are taken by students
Ngen=500; % the number of generations
up=ones(1,subj_num)*100; % upper boundary to the variables
low=ones(1,subj_num)*(-100); % lower boundary to the variables
Nrun=50;
fitness=zeros(stu_num,1);
xnew=zeros(stu_num,subj_num);
fxnew=zeros(stu_num,1);
gbest_fitness=zeros(1,Ngen);
global_value=zeros(Nrun,Ngen);
t0=cputime;
% aa=0;
for run=1:Nrun

%----------------------------------------------------------
range=repmat((up-low),stu_num,1); %10*2
lower=repmat(low,stu_num,1); % 10*2
x=[1,2,3;4,5,6;7,8,9].*range+lower; %intial random solution
for i=1:stu_num
fitness(i)=f(x(i,:));
end
%------------------------------------------------------%
for gen=1:Ngen
% aa=aa+1
%%%%%%%%%%% teaching phase %%%%%%%%
xmean=mean(x); % mean of the total students
index=find(fitness==min(fitness)); % capturing the teacher
position using objective function values
bt=index;
teacher=x(bt,:);
difference=0.5*(teacher(1,:)-round(1+0.5)*xmean(1,:));
%------------------------------------------------------------%
for i=1:stu_num
for j=1:subj_num %%% improving the initial solution in
teacher phase
xnew(i,j)=x(i,j)+difference(1,j);
if(xnew(i,j)>up(1,j)) % for values goes beyound upper
limit
xnew(i,j)=up(1,j);
elseif(xnew(i,j)<low(1,j)) % for values goes beyound lower
limit
xnew(i,j)=low(1,j);
end
end
end
%------------------------------------------------------------%
 for i=1:stu_num
fxnew(i)=f(xnew(i,:));
end
for i=1:stu_num %% applying greedy selection process
if( fxnew(i)<fitness(i)) % if old value is better then keep it
as it is
fitness(i)=fxnew(i);
x(i,:)=xnew(i,:);
end
end

%%%%%%%%%%%%%% learner phase %%%%%%%%%%%%%%

%% b1=floor(rand()*stu_num+1);
% bestl(1,:)=x(b1,:);

%% improving the level other learners using best learner

for i=1:stu_num
b1=floor(0.5*stu_num+1);
if i~=b1
if fitness(b1)<fitness(i)
xnew(i,:)=x(i,:)+0.5*(x(b1,:)-xnew(i,:));
else
xnew(i,:)=x(i,:)+0.5*(xnew(i,:)-x(b1,:));
end
else
b1=floor(0.5*stu_num+1);
if fitness(b1)<fitness(i)
xnew(i,:)=x(i,:)+0.5*(x(b1,:)-xnew(i,:));
else
xnew(i,:)=x(i,:)+0.5*(xnew(i,:)-x(b1,:));
end
end
end
for i=1:stu_num
fxnew(i)=f(xnew(i,:));
end
for i=1:stu_num %% applying greedy selection process
if( fxnew(i)<fitness(i)) % if old value is better keep it as it is
fitness(i)=fxnew(i);
x(i,:)=xnew(i,:);
end
end
c1=find(fitness==min(fitness));
gbest_fitness(gen)=fitness(c1(1,1));
end
global_value(run,:)= gbest_fitness;

end
disp ('num of iterations')
disp (Ngen)
mean_bestvalue=mean(global_value) ; % Mean global min
disp('fitness')
disp (mean_bestvalue(Ngen))
disp('bestparticle')
disp(x(c1,:))
gen=1:Ngen;
plot(gen,mean_bestvalue(gen))
xlabel('Generations')
ylabel('Mean of global minimum')
t=cputime-t0;
disp('total time of running')
disp(t)

.
Mean of Best fitness =14.1858
Mean of best fitness values = 0.0013
 GENETIC ALGORITHM
Taxonomy:

Inspiration:

Strategy:

Procedure:
Heuristics:

Code-Listing:

%% Function Optimization Of Non-linear Function using Genetic Algorithm%%

clc;
close all;
clear all;

%------------------------------ Intialization ---------------------------%

%random matrix
x=[1 2 3 4];

x1=zeros(1,4);
%------------------------- Generating binary code -----------------------%
for i=1:1:4
x1(i)=x(i);
for j=1:1:4
X(i,5-j)=rem(x1(i),2);
x1(i)=floor(x1(i)/2);
end
end

x2=x;
x2=x2';

for l=1:1:12
%--------------------- Generating Non Linear Function -------------------%
y=h(x); h(x)-> function define
p=max(y);
Y=sort(y,'descend'); %-------- sorting in descending order

%-------------- Discarding Lower Strata and Starting Crossover-----------%

%step1 - swapping X data in the descending order

for i=1:1:4

for j=1:1:4

if (y(j)==Y(i))
Z(i,:)=X(j,:);
end

end
end

%step2 - discard lower 2 data values of Y and Z(Probability = 0.8)

Y=Y(1:2);
Z=Z(1:2,:);
Parents=Z; %Parents

%step3 - starting crossover

n=[1 2];
m=ceil(0.5*4)-1;

for i=1:2:2

CrossoverZ(n(i),1:4)=[Z(n(i),1:m) Z(n(i+1),m+1:4)];
CrossoverZ(n(i+1),1:4)=[Z(n(i+1),1:m) Z(n(i),m+1:4)];

end
Crossover_Child=CrossoverZ; %crossover
%--------------------------- Starting Mutation --------------------------%

%Probability =0.1, change any single random value in each to

opposite(0to1)
Mutation_Child=Crossover_Child;

o=ceil(0.5*4);

for i=1:1:2

if (Crossover_Child(i,o)==0)
Mutation_Child(i,o)=1;
else if (Crossover_Child(i,o)==1)
Mutation_Child(i,o)=0;
end
end

end

%Parent,Crossover and Mutation childs are made

%Putting them into Fitness Funtion
Final_data=[Parents; Crossover_Child; Mutation_Child];
Final_data_int=zeros(1,6)';

%Converting binary to integers

for i=1:1:6

for j=1:1:4
Final_data_int(i)= Final_data_int(i)+power(2,4-j).*Final_data(i,j);
end

end

Final_data_int1=k(Final_data_int);

Output=Final_data_int1;
Output1=sort(Output,'descend');

for i=1:1:6 %%--for rosenbrook func i=1:4 &

j=1:4--%%

for j=1:1:6

if (Output1(i)==Output(j))
Final_Output(i,:)=Final_data(j,:);
end

end
end
Final_Output=Final_Output(1:4,:);

x2=Output1(1:1,:);

maximum(l)=Output1(1);

end

%---------------------- Plotting the final values -----------------------%

maximum=sort(maximum,'ascend');
k=1:1:1;
plot(k,maximum,'--rs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','g',...
'MarkerSize',7)
xlabel('no of generations')
ylabel('best solution')
Maximum value = 16909

Maximum value =139

For

Maximum value = 4189

Maximum value = 1.9487.

Maximum value = 0.4349.

In Ackley function:

Maximum value = 11.0134

 CULTURAL ALGORITHM





 

% --- == Cultural algorithm to solve nonlinear unconstrained function

optimization problem %
clc;
clear all;

popSize = 8; % the size of the initial population

pop = []; % population space, a one-dimensional function optimization
function
popSon = zeros (popSize, 1); % offspring population
f = zeros (popSize, 1); %fitness value of population
c = 6; % number of individuals from the population randomly
removed
suitKnowledge = []; % situational knowledge
normKnowledge = zeros (popSize, 2);% normative knowledge
gmax = 6; % maximum evolution algebra
acc = 0.95; % acceptance probability function that accepts

% ======================= Initial population space ===============

% One-dimensional function
for i = 1: popSize
pop(i) =19.2; % pop of real coding structure %%NEEDS TO BE CHANGED
WITH EACH FUNC%%
end

% Calculate the population fitness ========== ================%

for i = 1: popSize
f (i) = fit (pop (i));
end
% Initialize the belief space ======================
======================== ===============
[Fbest, bestnum] = min (f);
suitKnowledge = pop (bestnum); % initialize situational knowledge
for i = 1: popSize
normKnowledge (i, 1) = -32; % n order to standardize knowledge
normKnowledge (i, 2) = 32; % n The first column is the value of the
lower limit of %%Needs to be changed with each function%
% the second column is the value of x upper limit
end

% ----------------------- "Into the big loop" --------------------- ------

----------
for u = 1: gmax

% =================== Influence function (generate progeny)==== %

% -version1: Use knowledge to control the step size, the use of
situational knowledge to adjust its direction of change.
for i = 1: popSize
if (pop (i) <suitKnowledge)
popSon (i) = pop (i) + abs ((normKnowledge (i, 2) -
normKnowledge (i, 1)) * 0.5);
elseif (pop (i)> suitKnowledge)
popSon (i) = pop (i) -abs ((normKnowledge (i, 2) -
normKnowledge (i, 1)) * 0.5);
elseif (pop (i) == suitKnowledge)
popSon (i) = pop (i) + (normKnowledge (i, 2) -normKnowledge
(i, 1)) * 0.5;
end
end
popSon;% generated offspring individuals

for i = (popSize + 1) :( 2 * popSize)

pop (i) = popSon (i-popSize); % later The resulting offspring
individuals into parent individuals
end

% ============ Son competition (winning record) ================== %

winnum = zeros (2 * popSize, 1);% the number of each individual record
victory

for i = 1: 2 * popSize
cnum = [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16];
winsingle = 0;
for j = 1: c
if (fit (pop (i)) <fit (pop (cnum (j)))) ;% of each individual
and the individuals randomized comparison
winsingle = winsingle + 1;% record number of victories
end
end
winnum (i) = winsingle;
end
 index = 1;
for i = 1: 2 * popSize% will pop sorted by number of wins, Bubble Act
for j = (i + 1): 2 * popSize
if (winnum (i) <winnum (j)) % The number of victories in
descending order
uusee = winnum (i);
winnum (i) = winnum (j);
winnum (j) = uusee;
index = j; % index is the most pop index number
corresponding to the i-th win
end
end
pptv = pop (i);
pop (i) = pop (index);% will pop the new row by winning number
will win more times before the 40 individuals into the parent
pop (index) = pptv;
end

for i = 1: 2 * popSize
f (i) = fit (pop (i));% compute a new generation of parent
individuals fitness value
end

[Fbest, bestnum] = min (f (1: popSize));% removed before 40 newborn

population of the best individual
f;
pop;

% =========== Acc acceptance probability function =============%

if(Fbest<fit(suitKnowledge))
if(0.5<=acc) % probability acc merit accept situational knowledge
suitKnowledge=pop(bestnum);
end
end
for i=1:popSize

if((pop(i)<normKnowledge(i,1))||(fit(pop(i))<fit(normKnowledge(i,1))))
if(0.6<=acc)% probability acc merit accepted norms of knowledge
normKnowledge(i,1)=pop(i);
end
end

if((pop(i)>normKnowledge(i,2))||(fit(pop(i))<fit(normKnowledge(i,2))))
if(0.5<=acc)% probability acc merit accepted norms accepted knowledge
normKnowledge(i,2)=pop(i);
end
end
end
pop;

% Situational knowledge and normative knowledge (belief space)

completed the update
 trend (u) = Fbest;
trendindex (u) = suitKnowledge;
% Drawca (trendindex (u), trend (u));% drawing function
end

% ------------------------- "Big loop over" -------------------------- %

disp(trend)
disp(Fbest)

g=1:6;
figure(2);
plot(g,trend,'k');
title ('cultural algorithm ');
xlabel('no of generation')
ylabel('best fitness')

MEMETIC ALGORITHM
Procedure Memetic Algorithm
Initialize: Generate an initial population;
while Stopping conditions are not satisfied do
Evaluate all individuals in the population.
Evolve a new population using stochastic search operators.
Select the subset of individuals, , that should undergo the individual
improvement procedure.
for each individual in do
Perform individual learning using meme(s) with frequency or probability of
, for a period of .
Proceed with Lamarckian or Baldwinian learning.
end for
end while

%% Memetic algorithm for non-linear function source

% --------------------------------------------------- %
clc;
clear;
tic;
M=4;

% Chromosome number
P_mutate=0.1;
% Mutation probability
P_cross=0.95;
% Crossover rate
D=8;
%Dimension function
NCmax=6;
%Iterations
Xmax=100; %% depends on function %%
Xmin=-100;

for i=1:M
for j=1:D
X(i,j)=0.8*(Xmax-Xmin)+Xmin;
%Population initialization
end
end
for i=1:M
fitness(i)=Test_Function(X(i,:));
%Calculation fitness
end
for NC=1:NCmax
%% Hybrid
randrow=[2 1 3 4];
s=1;
for i=1:M/2
if 0.4<=P_cross
w1=0.4;w2=0.3;
X(M+s,:)=w1*X(randrow(i),:)+(1-w1)*X(randrow(M-i),:);
X(M+s+1,:)=w2*X(randrow(M-i),:)+(1-w2)*X(randrow(i),:);
s=s+2;
end
end
%% Variation
s=1;
new_M=size(X,1);
for i=1:new_M
if 0.03<=P_mutate
if 0.4<0.5
X(new_M+s,:)=X(i,:)+(Xmax-X(i,:))*(rand*(1-NC/NCmax))^2;
else
X(new_M+s,:)=X(i,1)+(Xmax-X(i,1))*(rand*(1-NC/NCmax))^2;
end
s=s+1;
end
end
%% Selection
 new_fitness(1:M)=fitness;
for i=M+1:length(X)
new_fitness(i)=Test_Function(X(i,:));
end

[iteration_fitness(NC),flag]=min(new_fitness);
nextX(1,:)=X(flag,:);

nextfitness(1)=new_fitness(flag);
P_select=(1./new_fitness)/sum((1./new_fitness));
%Computing selection probabilities
cum_P_select=cumsum(P_select);
for i=2:M
pos=find(cum_P_select>=0.3);
nextX(i,:)=X(pos(1),:);
nextfitness(i)=new_fitness(i);
end
X=[];fitness=[];
X=nextX;
fitness=nextfitness;
nextX=[];P_select=[];sum_P_select=[];nextfitness=[];
new_fitness=[];
for i=1:M
[X(i,:),fitness(i)]=fminsearch('Test_Function',X(i,:));
%Use matlab own local search functions
end
end
toc;
plot(iteration_fitness);
title('MEMETIC ALGORITHM')
xlabel('no of iterations')
ylabel('best fitness')

disp('best fitness')
[Best_fitness,flag]=min(fitness);
disp(Best_fitness);
disp('best solution')
disp(Best_fitness);
Best_solution=X(flag,:);
In Sphere function:

Cultural algorithm Memetic algorithm

Best fitness = 900 Best fitness =9.1937e-9

In Rastrigin function:

Cultural algo (best fitness =10.4431) Memetic algo. (best fitness =71.6368)

In Rosenbrock function:
 Cultural algo. (best fitness =0 ) Memetic algo. (best fitness =3.9859)

In Griewank function:

Cultural algo.( Best fitness = 9.6985) Memetic algo.( Best fitness = 0.0197)

In Schaffer function:
 Cultural algo. (best fitness =0) Memetic algo. (best fitness = 0.1384)

In Schwefel function:

Cultural algo.( Best fitness = 415.1478) Memetic algo.( Best fitness = 3.3203e+3)

In Ackley function:
Cultural algo.(best fitness =-2.7882e+04)

RESULTS & DISCUSSIONS:

ALGORITHM TYPE TEST FUNCTIONS Best fitness Conclusion
[OBJECTIVE value:
FUNCTION]
1. Neural No 1) Sphere function 0.0788 It exhibits the minimum
network-MLP expression 2) Rosenbrock function 0.0648 error for rosenbrock
3) Rastrigrin function 0.0796 function.
4) Griewank function 0.6147
5) Schaffer function 1.4257
6) Ackley function 0.0772
7) Schwefel's function 0.1323
2. Neural No 1) Sphere function 0.1064 It exhibits the minimum
network -RBF expression 2) Rosenbrock function 3.8617e+04 Error/ best output for
3) Rastrigrin function 6.50590 Sphere function.
4) Griewank function 1.4361
5) Schaffer function 13.0976
6) Ackley function 9.9121
7) Schwefel's function 3.9375
3. Genetic No 1)Sphere function 49 It produces the best result for
algorithm expression 2) Rosenbrock function 16909 Rosen Brock function.
3) Rastrigrin function 139
4) Griewank function 1.9487
5) Schaffer function 0.4349
6) Ackley function 11.0134
7) Schwefel's function 4189
4. Teaching No 8) Sphere function 0.1439 It exhibits the best fitness
learning expression 9) Rosenbrock function 12.9603 Value for Schwefel’s
based 10) Rastrigrin function 14.1858 Function.
optimization 11) Griewank function 0.1650
12) Schaffer function 0.3753
13) Ackley function 18.8849
14) Schwefel's function 0.0013
5. Cultural No 15) Sphere function 900 It gives best solution
expression 16) Rosenbrock function 0 i.e. best fitness for Ackley
17) Rastrigrin function 10.4431 function .
18) Griewank function 9.6985
19) Schaffer function 0
20) Ackley function -2.7882e+04
21) Schwefel's function 415.1478
6. Memetic No 22) Sphere function 9.1937e-9 It gives the best solution for
expression 23) Rosenbrock function 3.9859 Sphere function.
24) Rastrigrin function 71.6368
25) Griewank function 0.0197
26) Schaffer function 0.1384
27) Ackley function
28) Schwefel's function 3.8203e+03
Population based methods for function finding
1) When objective function is given and data is given
2) When data is given and objective function is not given
CONCLUSIONS AND SCOPE FOR FURTHER STUDY
PUBLICATIONS DONE