Simple Genetic Algorithm (by TRB)

Genetic Algorithms (GA) are the most popular techniques in evolutionary computing [72].
Various applications of GAs have been reported in literature. In this research, GA is proposed for
solving the optimization of HEN cleaning schedule. No report has been found in the literature on
the application of GA for HEN cleaning schedule optimization.

The major differences between GA and conventional optimization methods are summarized in
Table Error! No text of specified style in document..1. GA is recommended for solving
optimization problems with the following conditions [72]:

1 The search space is large, complex or unpredictable

2 Domain knowledge is scarce or expert knowledge is difficult to encode to narrow the search
space

3 The mathematical analysis is unavailable

4 Traditional search fails.

Among the various GA algorithms reported, simple GA is easier, famous, and widely employed.

Table Error! No text of specified style in document..1. The major differences between GA and
conventional optimization methods

No Conventional Genetic Algorithm

1 Conventional methods work with GAs work with the coding of solution
the solution itself. set.
2 Almost all conventional GAs always operate on a whole
optimization techniques search from population of points (strings)
a single point
3 Conventional methods use GA uses fitness function for evaluation.
derivatives for evaluation As a result, they can be applied to any
 kind of continuous or discrete
optimization problem.
4 Conventional methods for GAs use probabilistic transition rules.
continuous optimization apply
deterministic transition rules

GAs suffer a few disadvantages: GAs are not proper for real time applications and take long
time to reach the optimal solution. It should be noted that in most cases where conventional
optimization methods can be applied, GAs are much slower because GAs do not take secondary
information like derivatives into account. The huge potential of GAs lies when the optimization is
non-differentiable or even discontinuous functions such as optimization of cleaning schedule of
HEN.

In a simple GA, the cleaning period for each heat exchanger is represented as a chromosome. There
are variations of chromosomes in one generation. The chromosomes are processed using three
operators, namely: selection, crossover, and mutation. In this study, elitism is also implemented in
the optimization of cleaning schedule. Elitism is a mechanism that guarantees top-fit chromosomes
in a population are always taken to the next generation.

Selection

The role of parent selection (mating selection) is to make a distinction among individuals based
on their quality to permit the better individuals to become parents of the next generation. Parent
selection is probabilistic. Thus, high quality individuals will get a higher chance to become parents
than those with low quality. The proportionate reproductive operator is commonly used where a
string is selected from the mating pool with a probability proportional to the fitness.

Roulette selection is one of the traditional GA selection techniques. The principle of roulette
selection is a linear search through a roulette wheel with the slots in the wheel weighted in
proportion to the individual’s fitness values. A target value is set, which is a random proportion of
the sum of the fitness values in the population. The population is stepped through until the target
value is reached. The wheel is spun N times, where N is the number of individuals in the
population. On each spin, the individual under the wheel’s marker is chosen to be in the pool of
parents for the next generation.

The method applied is as follows:

1) Sum the total expected value of the individuals in the population. Let it be T.
2) Repeat N times:
i. Choose a random integer, r, between 0 and T.
ii. Loop through the individuals in the population, summing the expected values, until the
sum is greater than or equal to r. The individual whose expected value pushes the sum
over this limit is the one selected.

Crossover

Crossover is the method of taking two parent solutions and generating from them a child. After
the selection (reproduction) process, the population is enhanced with better individuals.
Reproduction makes clones of good strings but does not produce new ones.

Crossover is a recombination operator that is carried out in three steps:

1. The reproduction operator chooses a couple of two individual strings for the mating,
randomly.
2. A crossover site is chosen at random along the string length.
3. The position values are exchanged between the two strings following the crossover site i.e.,
all the bits before and after this point are copied from the first and second parents, respectively
to produce the child as shown in Figure Error! No text of specified style in document..1.
 Figure Error! No text of specified style in document..1. Single point crossover

If appropriate crossover site is chosen, better children can be obtained by combining good
parents else it will severely obstruct string quality. The basic parameter in crossover method is the
crossover probability (Pc). Crossover probability expresses the portion of crossover in the new
generation. Offspring are exact copies of parents without crossover. If crossover is used, offsprings
are built from parts of both parent’s chromosome. If crossover probability is 100%, in that case all
offsprings are made by crossover. If it is 0%, the whole new generation is built from exact copies
of chromosomes from old population. Crossover is made in expecting that new chromosomes will
contain good parts of old chromosomes and thus the new chromosomes will be better. However,
it is good to retain some part of old population that survives to next generation.

Mutation

Mutation plays the role of improving genetic materials by randomly disturbing the genetic
information. Mutation has traditionally been considered as a simple genetic operator. If crossover
is expected to exploit the current chromosomes in population to find better ones, mutation is
supposed to help for the exploration of the whole search space. It establishes new chromosomes
in the population by randomly modifying some of its building blocks. Mutation helps escaping
from local minima’s trap and maintains chromosomes diversity in the population. It also keeps the
gene pool well stocked, and thus ensuring dynamics of gene processing. Mutation of a bit involves
flipping a bit, changing 0 to 1 and vice-versa. A simple mutation inverts the value of each gene
with a low probability.

The essential parameter in mutation operation is the mutation probability (Pm). The mutation
probability expresses the portion of chromosomes that will be mutated. Without mutation, the
offspring are copied without any change. If mutation is performed, one or more parts of a
chromosome are modified. If mutation probability is 100%, whole chromosomes are modified, if
it is 0%, no chromosome is modified. Mutation probability should be a low value, since GA with
high mutation probability will become an absolute random-search algorithm.

Figure Error! No text of specified style in document..2 shows the mutation concept. A parent
is considered and a child chromosome is produced by mutation. If the generated random value is
lower than the mutation probability, then the corresponding bit in a parent chromosome is flipped
(0 to 1 and 1 to 0) and child chromosome is generated. For example, the mutation genes occur at
2 places (bold and italic fonts), the corresponding bits in parent chromosome are flipped and child
is generated.

Parent 1 0 0 1 1

Child 1 0 1 0 1

Figure Error! No text of specified style in document..2. Mutation flipping

Elitism

The method in which the offspring and parents merge to form the new population for the next
generation is another GA design consideration that has a direct effect on the optimization
performance. A non-elitist method will replace all individuals in the current population while an
elitist one always keeps the best solutions found in the previous population. The former approach
may result in a slow convergence while the later may cause the search to be trapped in a local
optimum.
 An elitism mechanism is employed in the GA for faster convergence. The elitism method
involves picking a number of elite chromosomes (5% of the population size) in the current
population and combining with the processed chromosomes in the evolving population. The
flowchart of elitism is shown in Figure Error! No text of specified style in document..3.

Start

Read fitness value for each

chromosome in current generation

Sort the chromosomes by fitness value

Take 5% elite chromosomes in current generation

and combine with processed chromosomes

End

Figure Error! No text of specified style in document..3. Flowchart of elitism

1.1 Optimization of Cleaning Schedule of HEN using GA

In order to solve the mixed integer nonlinear programming (MINLP) problem in HEN cleaning schedule,
simple genetic algorithm is utilized. The solution provides the optimum cleaning period for the 11 heat
exchangers by minimizing the optimization problem in (5.8). Cleaning period for each heat exchanger is
designed to be between 0 to 31 months represented by 5 bits in a chromosome (Table Error! No text of
specified style in document..2). Hence, the total number of bits in a chromosome for 11 heat
exchangers is 55. Fitness value is obtained by simulating HEN under fouling conditions at different
cleaning period scenarios during the time horizon of 0 to tF.

Table Error! No text of specified style in document..2. Cleaning period of a heat exchanger in a
chromosome

Binary Decimal Cleaning period(month)

0 0 0 0 0 0 No cleaning
0 0 0 0 1 1 1
 0 0 0 1 0 2 2
●
●
●
1 1 1 1 1 31 31
The flowchart of the solution of the HEN cleaning schedule optimization problem is shown in Figure
5.4. A brief explanation of the steps shown in the flowchart is as follows:

Step 1. GA creates a population of 100 individuals of 55 bits each assigned arbitrarily or randomly

Step 2. Calculate the fitness of all chromosomes in the population using the HEN process simulation
model under fouling conditions.

Step 3. GA processing

a. Select a pair of parent chromosomes from the current population, the probability of
selection being an increasing function of fitness. Selection is done with replacement,
meaning that the same chromosome can be selected more than once to become a parent.
b. With probability Pc = 0.7 (the crossover probability or crossover rate), cross over the pair at
a randomly chosen point (chosen with uniform probability) to form two offspring. If no
crossover takes place, form two offspring that are exact copies of their respective parents.
c. Mutate the two offspring at each locus with probability Pm = 0.001 (the mutation probability
or mutation rate), and place the resulting chromosomes in the new population.
Step 4. Replace the current population with the new population.

Step 5. Calculate the fitness of each chromosome in the new population.

Step 6. Elitism mechanism automatically keeps 5% top-fit individuals from the current population. The
rest of the new population is filled out by the normal selection, crossover, and mutation
procedure.

Step 7. Stopping criteria. If the change in the fitness value between the current and the previous
generations is less than the tolerance limit, it is assumed that the optimum has been reached.
Otherwise, go to step 3. In this case, the maximum number of generations is fixed to be 100
and if no optimum is found with the 100 generations, the optimization is restarted with a
different starting population.
 Start

Generate populations

Calculate fitness value by simulating HEN

under different cleaning schedule scenarios

Selection

Crossover Elitsm

Mutation

Calculate fitness values by simulating HEN under

different cleaning schedule scenarios

No
Iteration > 100 ?

Yes

End

Figure Error! No text of specified style in document..4. GA flowchart

clear all;
close all;
clc;

Hasilmax=[];
fitnessvector =[];

Population = 100;
MaxGeneration = 200;
Kromosom = 20;
elitism = 0.1;
ProbCrossOver = 0.8;
ProbMutate = 0.5;
% Individu = [];
IndividuInteger = [];
eIntSc = [];
esched = [];
Datafit = [];
Data1fit = [];
DataSort = [];
ElitIndividu = [];
HMI = [];
DataFGAfit = [];
maxall = [];

%=====Generasi Popoulasi=====
Individu = floor(rand(Population,Kromosom)+rand());

%=====Binary to Int=====
for i = 1:(Kromosom./10)
for j = 1:Population
IndividuInteger(j,i) = bi2de(Individu(j,((i*10)-9):(i*10)),'left-
msb');
end
end

Datafit = [];

for k = 1:Population

X0 = (((IndividuInteger(k,1)-0)/1024)*10);
Y0 = (((IndividuInteger(k,2)-0)/1024)*10);

%=======fitness function==============
% cost = -(X0*sin(4*X0)) - (1.1 * Y0 * sin(2*Y0));
cost = -((((X0.^2)+(Y0.^2)).^0.5).*cos((X0)-
(Y0))).*exp(cos(((X0).*(Y0+5))./7));;

%======================================
 fitness = cost;
Datafit = [Datafit;fitness];
[fitemax,nmax] = max(Datafit);

end
disp('GA Processing');
for Generasi = 1:MaxGeneration

%=====GA Processing=====

if (Generasi > 1)

%=====sortir=====
sort_fit = sortrows(sort, Kromosom + 1);
Individu1 = sort_fit(round((1-elitism)*Population+1):Population,:);
Remain = sort_fit(round(elitism*Population) + 1:Population, :);

X = Individu1;
M = size(X,1);

for i=1:M
fitnessvector(i) = X(i,Kromosom + 1);
end

fitnessvector = fitnessvector';

%=====Setting Probability=====
for i=1:M
Probability(i) = fitnessvector(i) / sum(fitnessvector);
end

for i=2:M
Probability(i) = Probability(i) + Probability(i-1);
end

for i = 1:M
n=rand;
k=1;
for j =1:M-1
if (n>Probability(j))
k = j+1;
end
end
Xparents(i,:) = X(k,:);
end

%=====Crossover=====
[M,d] = size(Xparents);
Xcrossed = Xparents;
for i=1:2:M-1
c = rand;
 if (c<=ProbCrossOver)
p = ceil((d-1*rand));
Xcrossed(i,:) = [Xparents(i,1:p) Xparents(i+1,p+1:d)];
Xcrossed(i+1,:) = [Xparents(i+1,1:p) Xparents(i,p+1:d)];
end
end
if (M/2~=floor(M/2))
c = rand;
if (c<=ProbCrossOver)
p = ceil((d-1)*rand);
str = ceil((M-1)*rand);
Xcrossed(M,:) = [Xparents(M,1:p) Xparents(str,p+1:d)];
end
end

%=====Mutation=====
[M,d] = size(Xcrossed);
Xnew = Xcrossed;
for i=1:M
for j=1:d
p = rand;
if (p<=ProbMutate)
Xnew(i,j) = 1-Xcrossed(i,j);
end
end
end

%=====New Population Fitness Calculation=====

Individu = [Xnew(:,1:Kromosom);Remain(:,1:Kromosom)];
end

ElitIndividu = [ElitIndividu; Individu];

for i = 1:(Kromosom./10)
for j = 1:Population
IndividuInteger(i,j) = bi2de(Individu(j,((i*10)-9):(i*10)),'left-
msb');
end
end

Datafit = [];

for po = 1:Population
X0 = (((IndividuInteger(1,po)-0)/1024)*10);
Y0 = (((IndividuInteger(2,po)-0)/1024)*10);

%=======fitness function==============
% cost = -(X0*sin(4*X0)) - (1.1 * Y0 * sin(2*Y0));
cost = -((((X0.^2)+(Y0.^2)).^0.5).*cos((X0)-
(Y0))).*exp(cos(((X0).*(Y0+5))./7));
%=====================================
 fitness = cost;
error = 0.001;
Datafit = [Datafit;fitness];
end

Data1fit = Datafit;
[fitnessmax, nmax] = max(Data1fit);
DataFGAfit = [DataFGAfit;fitnessmax];
IndividuMax = Individu(nmax,:);
IndividuMaxLast = IndividuMax;
Hasilmax = IndividuMax;
sort = [Individu Datafit];
maxall = [maxall; sort];
for i = 1:(Kromosom./10)
HasilMaxInt(1,i) = bi2de(Hasilmax(1,((i*10)-9):(i*10)),'left-msb');
end
HMI = [HMI; HasilMaxInt(1,1), HasilMaxInt(1,2)];
end

plot(DataFGAfit);
hold on

[fitnessmaxf, nmaxf] = max(DataFGAfit);

X0maxfix = (((HMI(nmaxf,1)-0)/1024)*10);
Y0maxfix = (((HMI(nmaxf,2)-0)/1024)*10);

X0maxfix
Y0maxfix
[fitnessmaxf, nmaxf] = max(DataFGAfit)