Solving MOOP_ Pareto-based MOEA Approaches

Solving MOOP: Pareto-based MOEA approaches
Debasis Samanta
Indian Institute of Technology Kharagpur

[email protected]
29.03.2016
Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 1 / 70

MOEA strategies
MOEA Solution
Techniques
A priori approach A posteriori approach
Independent sampling
Lexicographic ordering
Aggregate Selection
Game theory approach
Criterion selection (VEGA)
Non-linear fitness evaluation
Pareto selection
SOEA
Min-Max method
Ranking (MOGA)
Ranking and Niching
Demes
Elitist

MOEA strategies
MOEA Solution
Techniques
A priori approach A posteriori approach
Independent sampling
Lexicographic ordering
Aggregate Selection
Game theory approach
Criterion selection (VEGA)
Non-linear fitness evaluation
Pareto selection
SOEA
Min-Max method
Ranking (MOGA)
Ranking and Niching
Demes
Elitist

MOGA : Multi-Objective Genetic Algorithm

MOGA : Multi-Objective Genetic Algorithm
It is Pareto-based approach based on the principle of ranking

mechanism prposed by Carlos M. Fonseca and Peter J. Fleming
(1993).
Reference :
C. M. Fonseca and P. J. Fleming, ”Genetic Algorithm for
multi-objective Optimization : Formulation, Discussion and
Generalization” in Proceeding of the 5th International Conference
on Genetic Algorithm, Page 416-423, 1993.
Regarding the ”generation” and ”selection” of the Pareto-optimal
set, ordering and scaling techniques are required.
MOGA follows the following methodologies:

For ordering: Dominance-based ranking,
For scaling: Linearized fitness assignment and fitness averaging.

Flowchart of MOGA
Converged ?

Dominance-based ranking
Definition 6 : Rank of a solution

The rank of a certain individual corresponds to the number of
chromosomes in the current population by which it is dominated.
More formally,
If an individual xi is dominated by pi individuals in the current
generation, then rank(xi ) = 1 + pi

Example 1: Dominance-based ranking
Min f2
xi
Xi
Min f1
Rank(x1)=1+|xi|
Where |xi| = number of solutions in
the shaded region

Max f2
xi
Max f1
Rank(x1)=1+11=12

Max f2
1
8 1
Max f1
Number of dominated points

with their domination count
Interpretation : Dominance-based ranking
Note :
1 Domination count = How many individual does an individual

dominates
2 All non-dominated individuals are assigned rank 1.
3 All dominated individuals are penalized according to the
population density of the corresponding region of the trade-off
surface.

Fitness Assignment in MOGA
Steps :
1 Sort the population in ascending order according to their ranks.

2 Assign fitness to individuals by interpolating the best (rank 1) to
the worst (rank ≤ N, N being the population size) according to
some linear function.
3 Average the fitness of individual with the same rank, so that all of
them are sampled at the same rate.
This procedure keeps the global population fitness constant while

maintaining appropriate selective pressure, as defined by the function
used.

Fitness Assignment in MOGA
interpolation
Individual with rank i

f2
Linerization Rank i+1
f1
Pk fii
Example : Linearization = f̄i = j=1 f¯i
j
where fji denotes the j-th objective function of a solution in the i-th rank
and f¯i denotes the average value of the j-th objectives of all the
j
solutions in the i-th rank.
Illustration of MOGA
1 2 3 4 k l
1, 2, n
1 2
1 2 q

Remarks on MOGA
The fitness assignment (Step 3) in MOGA attempts to keep global

population fitness constant while maintaining appropriate
selection pressure.
MOGA follows blocked fitness assignment which is likely to

produce a large selection pressure that might lead to premature
convergence.
MOGA founds to produce better result (near optimal) in majority of

MOOPs.

Niched Pareto Genetic Algorithm (NPGA)
J. Horn and N. Nafploitis, 1993 Reference : Multiobjective

Optimization using the Niched Pareto Genetic Algorithm by J.Horn and
N.Nafpliotis, Technical Report University of Illionis at
Urbans-Champaign, Urbana, Illionis, USA, 1993

NPGA is based on the concept of tournament selection scheme
(based on Pareto dominance principle).
In this techniques, first two individuals are randomly selected for
tournament.
To find the winner solution, a comparison set that contains a
number of other individuals in the population is randomly selected.
Then the dominance of both candidates with respect to the
comparison set is tested.
If one candidate only dominates the comparison set, then the
candidate is selected as the winner.
Otherwise, niched sharing is followed to decide the winner
candidate.
The above can be specified as follows.
Pareto-domination tournament
let N = size of the population, K is the no of objective functions.
Steps :
1 i=1 (The first iteration)

2 Randomly select any two candidates C1 and C2
3 Randomly select a ”Comparison Set (CS)” of individuals from the
current population
Let its size be N ∗ (Where N ∗ = P%N; P decided by the
programmer)
4 Check the dominance of C1 and C2 against each individual in CS

4 If C1 is dominated by CS but not by C2 than select C2 as the

winner
Else if C2 is dominated by CS but not C1 than select C1 as the
winner
Otherwise Neither C1 nor C2 dominated by CS
do sharing (C1 , C2 ) and choose the winner.
5 If i = N 0 than exit (Selection is done)
Else i=i+1, go to step 2

A sharing is followed, when there is no preference in the

candidates.
This maintains the genetic diversity allows to develop a

reasonable representation of Pareto-optimal front.
The basic idea behind sharing is that the more individuals are
located in the neighborhood of a certain individual, the more its
fitness value is degraded.
The sharing procedure for any candidate is as follows.

Procedure do sharing(C1 , C2 )
1 j=1. Let x = C1
2 Compute a normalized (Euclidean distance) measure with the
individual xj in the current population as follows,
s 2
j
Pk fix −fi
dxj = i=1 f U −f L
i i
where fij denotes the i-th objective function of the j-th individual
fiU and fiL denote the upper and lower values of the i-th objective
function.

3 Let σshare = Niched Radius

Compute the following sharing value
( 2
dxj
1 − σshare , if dxj < σshare
sh(dxj ) =
0 , otherwise
4 Set j = j + 1, if j < N, go to step 2 else calculate ”Niched Count”
for the candidate as follows
n1 = N
P
j=1 sh dij
5 Repeat step 1-4 for C2 .
Let the niched count for C2 be n2
6 if n1 < n2 then choose C2 as the winner else C1 as the winner.

C1
C2
....
N*
C1
. . . . . . .
C2
Initial Population of Random Population

size N index

This approach proposed by Horn and Nafploitis [1993]. The approach

is based on tournament scheme and Pareto dominance. In this
approach, a comparison was made among a number of individuals
(typically 10%) to determine the dominance. When both competitors
are dominated or non-dominated (that is, there is a tie) the result of the
tournament is decided through fitness sharing (also called equivalent
class sharing)
The pseudo code for Pareto domination tournament assuming that all
of the objectives are to be maximized is presented below. Let us
consider the following.

Pareto domination Tournament
S = an array of N individuals in the current population.

random pop index = an array holding N individuals of S, in a random
order.
tdom = the size of the comparison set.

Algorithm Selection
1
Comparison_set_index 2
1
2 Candidate 1
Candidate 2
Comparison_individual
Random_pop_index
Population list

Algorithm Selection
This algorithm returns an individual from the current population S.
Begin
shuffle(random pop index)
candidate 1 = random pop index[1];
candidate 2 = random pop index[2];
candidate 1 dominated = F ;
candidate 2 dominated = F ;
for comparison set index = 3 to tdom + 3 do
comparison individual = random pop index[comparison set index];
if s[comparison set index]dominatess[candidate 1] then
candidate 1 dominated = TRUE;
end if
if s[comparison set index]dominatess[candidate 2] then
candidate 2 dominated = TRUE;
end if
end for
Algorithm Selection
if candidate 1 dominatedand ∼ candidate 2 dominated then

return candidate 1
else if candidate 2 dominatedand ∼ candidate 1 dominated then
return candidate 2
else
if nichecount(candidate 1) > nichecount(candidate 2) then
return candidate 2
else
return candidate 1
end if
end if
END

Algorithm Selection
This approach does not apply Pareto selection to the entire population,
but only to a segment of it at each num, the technique is very first and
produces good non-dominated num that can be kept for a large
number of generation.
However, besides requiring a sharing factor, this approach also
requires a good choice of the value of tdom to perform well,
complicating its appropriate use in practice.

Points to Ponder an Multi-objective Evolutionary
Algorithm
How you solve two optimization problem

Strategy 1 : Solve individually
Strategy 2 : Solve 1 as main as other as constraint
Strategy 3 : C = C1 + c2 , X = X1 ∪ X2
Justify three strategies
What are the issues with one minimize and another maximization
problem
Explain weighted-sum approach.
What are the issues ?
How pareto-based approach address this issues ?

Non-dominated Sorting Genetic Algorithm(NSGA)
N.Srinivas and K.Deb, 1994

Reference : Multi-objective Optimization using Non-dominated Sorting
in Genetic Algorithm by N.Srinivas and K.Deb, IEEE Transaction on
Evolutionary Computing, Vol. 2, No. 3, Pages 221-248, 1994.
The algorithm is based on the concept of

1 Non-dominated sorting procedure (a ranking selection method to
select good non dominated points.
2 Niche method (is used to maintain stable subpopulation of good
points)

Non-dominated Sorting Procedure
Notations :
xi - denotes i-th solution

Si - denotes a set of solutions which dominate the solution xi
P - denotes a set of solutions (input solutions)
Pk - denotes a non-domination front at the k-th level (output as
sorting based on the non-domination rank of solution)
ni denotes the domination count, i.e. the number of solutions
which dominates xi

xi
Max f2
Front 1
Front 2
Max f1
Front 4 Front 3

Steps :
1 For each xi ∈ P do
1 For all xj 6= xi and xj ∈ P

If xi ≤ xj (i.e. if xi ) dominates xj
then si = si ∪ xj
else if xj ≤ xi then ni = ni + 1
2 If ni = 0, keep xi in P1 (the first front). Set a front counter K = 1
2 [INITIALIZATION]
For each xi ∈ P, ni = 0 and Si = φ
< −− This completes the finding of first front −− >

< −− To find other fronts −− >
3 While Pk = φ do
1 [Initialize] Q = φ (for sorting next non-dominated solutions)

2 For each xi ∈ Pk and For each xj ∈ Si do
Update nj = nj − 1
If nj = 0 then xj in Q Else Q = Q ∪ xj
3 Set k = k + 1 and Pk = Q (Go for the next front)

Note : Time complexity of this procedure is O(MN 2 ), where M is the

number of objective and N is the population size.

An Illustration
2
5
4
4
f2 maximize
3
1 5
2
3
1
2 6 10 14 18
f1 maximize
Here, 1 dominates 2
5 dominates 1 etc.

Three non-dominated fronts as shown.
The solutions in the front [3, 5] are the best, follows by solutions
[1, 4].
Finally, solution [2] belongs to the worst non-dominated front.
Thus, the ordering of solutions in terms of their non-domination

level is : [3, 5], [1, 4], [2]

NSGA Technique
NSGA is based on several front of classification of the individuals.

It finds a front (of non dominated individuals) at particular rank and
then assign a fitness value (called dummy fitness value) to each
solution in the front followed by sharing of fitness value.
It then selects some individuals based on shared fitness values of
the individuals for mating pool.
Reproduce offspring for next generation and thus completes an
iteration.

Flowchart of NSGA
Start
MOOP
Initial Population
Encoding
Front k = 1
Is Population No Identified non-
Classification
Classified ?
dominated individual
Yes
Selection for mating Assign dummy fitness
pool value
Reproduction
Sharing
(Crossover, Mutation) Fitness sharing
Evaluate each
front k = k + 1
individual
No
Converged ?
Yes
Assign dummy fitness value
Once all non dominated individual are identified for a front, it

assigns a unique fitness value to each belongs to that front is
called dummy fitness value.
The dummy fitness value is a very large number and typically is
proportional to the number of population (which includes the
number of individuals in all fronts including the current front).
The proportional constant (≥ 1) is decided by the programmer

Assign dummy fitness value
Note :
The same fitness value is assigned to give an equal reproductive

potential to all the individual belong to the front.
A higher value is assigned to individuals in an upper layer front to
ensure selection pressure, that is, having better chance to e
selected for mating
As we go from an upper front to next lower front, count of
individuals are ignored (i.e. logically remove from the population
set) and thus number of population successive decreases as we
move from one front to next.

Sharing the fitness value
In the given front, all individuals are assigned with a dummy

fitness value which is proportional to the number of population.
These classified individuals are then shared with their dummy
fitness values.
Sharing is achieved by dividing the dummy fitness value by ”a
quantity proportional to the number of individuals around it”. This
quantity is called niche count.
This quantity is calculated by computing ”Sharing coefficient”
denoted as sh(dij ) between the individual xi ,xj belong to the front
under process, as per following.
( 2
dij
1 − Tshared , if dij < Tshared
sh(dij ) =
0 , otherwise
In the above, the parameter dij is the ”phenotype distance”
between two individuals xi and xj in the current front.

Tshare is the maximum phenotype distance allowed between any

two individuals to become members of a niche. This value should
be decided by the programmer.
Niche count of xi then can be calculated as
P
γ(xi ) = ∀xj ∈pk Sh(dij )
where Pk denotes the set of non dominated individual in the
current front k).
The shared fitness value of xi is then f¯i = f , where f is the
γ(xi )
dummy fitness value.

NSGA Technique
Individual are with

higher niche count
f2
Current front
f1

Note :
The sharing is followed to ensure the population diversity. That is,

give a fair chance to those individuals which are not so niche.
sh(dij ) 6= 0, and it always greater than or equal to 1 (=1 when
dij = 0).
After the fitness sharing operation, all individuals in the current
front are moved to a population set to be considered for mating
subject to their selection.
The assignment of dummy fitness value followed by fitness
sharing is then repeated for the next front (with a smaller
population size).

NSGA Selection
Once all fronts are processed, we obtained a set of population
with their individual shared fitness values.
This population is then through a selection procedure.
NSGA follows ”stochastic remainder proportionate selection”,
which is as follows.
1 Calculate cumulative probabilities of all individuals as in
Roulette-Wheel scheme.
2 Generate a random number (for first time only) ri (this is the
probability to get an individual to be selected).
3 If Pj−1 ≤ ri < Pj (where PJ and Pj−1 are two cumulative
probabilities, then consider j-th individual for the selection.
4 Let Ej = Pj × N (N, the population size and Ej denotes expected
count).
5 If integer part in Ej is nonzero, then select j-th solution for mating.
6 The fractional part is used as the random number for the selection
of next solution.
7 Repeat step 3-6 until the mating pool of desired size is not reached.
Reproduction and generation of new population
Follow the standard reproduction procedure as in Simple GA.

Remark on NSGA
Several comparative studies reveal that NSGA is outperformed by

both MOGA and NPGA.
NSGA is also highly inefficient algorithms because of the way in
which it classified individuals (if is O(MN 3 )) time complexity)
Deb et al. proposed an improved version of NSGA algorithm
called NSGA-II.
It needs to specify a sharing parameter.
Tshare It is a non-elitism appraoch.

Elitist Multi-objective Genetic Algorithm : NSGA-II
K.Deb, A.Protap, S.Agarwal and T.Meyarivan 2002.

Reference :
A Fast and Elitist Multi-objective Genetic Algorithm : NSGA-II by
K.Deb, A.Pratap, S.Agrawal and T.Meyarivan in IEEE Transaction on
Evolutionary Computation, Vol.6, No.2, Pates 182-197, April 2002.

The following approach of finding non-domination front is followed in

NSGA.
Notation
P = A set of input solution

xi and xj denote any two solution
P 0 = set of solutions on non-dominated front.

Approach
In this approach every solution from the population P is checked with a

partially filled population P 0 (which is initially empty). To start with, the
first solution from P is moved into initially empty P 0 . Thereafter, each
solution xi ∈ P one by one is compared with all member of the set P 0 .
If the solution xi dominates any member of P 0 , then that solution is
removed from P 0 . Otherwise, if solution xi is dominated by any
member of P 0 , the solution xi is ignored. On the other hand, if solution
xi is not dominated by any member of P 0 it is moved in to P 0 . This is
how the set P 0 grows with non dominated solutions. When all solutions
of P are checked, the remaining members of P 0 constitute the
solutions on non-dominated front.

This front is removed and the same steps are repeated with the
remaining solutions to find the next non-domination front until P is
empty. This approach is precisely stated in the following.
Steps :
P = x1 , x2 , · · · , xN
1 Initialize P 0 = xi set solution counter j = 2.

2 Let j = 1.
3 Compare solution xi with xj from P for domination
4 If xi ≤ xj , delete xj from P 0
5 If j < |P 0 |, then increment j by one and go to step 3.
Else Go to step 7.

6 If xj ≤ xi , then increment i by one and go to step 2.

7 Insert xi in P 0 i.e. P 0 = P 0 ∪ i
8 If i < N, increment i by one and go to step 2.
9 Output P 0 as the non-dominated from with current population
10 if P 6= φ, repeat Step 1-9.
11 Stop.
Note : Time complexity of this procedure is O(MN 2 ) and in worst

case O(MN 3 ) (when one front contains only one solution.)

Overview of NSGA-II
Let P be the current population

Create offspring population Q from P using the genetic operators
(mating pool, crossover and mutation)
Two population are combined together to form a large population
R of size of 2N
Apply non-dominating sorting procedure to classify the entire
population R.
After the non-domination sorting, the new population P is obtained
by fitting the non-dominated front one-by-one until the |P 0 | < |P|
The filling starts with the best non-dominated front followed by the
second non-dominated front, followed by the third non-dominated
front and so on.

Overview of NSGA-II
Since the total population size is 2N, not all fonts may be
accommodated in N stats available in P 0 . All fronts which could
not be accommodated are simply rejected. when the last allowed
front is being considered, there may exist more solution in the lase
front than the remaining slots in the new population.
Instead of arbitrarily discarding some members from the last
acceptable front, the solution which will make the diversity of the
selected solutions the highest are chosen.
This is accomplished by calculating crowding distance of solutions
in the last acceptable front.
This way a new generation was obtained and the steps are
repeated until it satisfies a termination condition.

NSGA Technique
F1 F1
F2 F2
P
Non-dominated Solution based on Fi
sorting Fi
crowding distance
P’
Last acceptable front

Q Rejected

Basic Steps : NSGA-II
Steps :
1 Combine parent (P) and offspring (Q) populations and obtain
R =P ∪Q
2 Perform a non-dominated sorting to R and identify different fronts
of non-dominated solutions as Fi , i = 1, 2, · · · , etc.
3 Set new population P 0 = φ. Set a new counter i = 1 (to indicate
front to be allowed to fill P 0 .
4 Fill P 0 until |P 0 | + |Fi | < N that is, P 0 ∪ Fi and i = i + 1.
5 Perform Crowding sort (Fi ) and include the most-widely spread
N − |P 0 | solution by using the crowding distance values in the
sorted Fi to P 0 .
6 Create offspring population Q 0 from P 0 by using the
crowded-tournament selection, crossover and mutation operator.
7 P = P 0, Q = Q0.
8 Repeat step 1-7 until the convergence of solutions.
Crowding sort procedure
The crowding sort follows the following two concepts.

Crowding distance metric (d) and
Crowded comparison operator <e
Note :
The crowding distance di of a solution xi is a measure of the

search space around xi which is not occupied by any other
solutions in the population. (It is just like a population density : di
is lower for a dense population.
The crowded comparison operator <e (a binary operator) to

compare two solutions and returns a winner.

Definition 8 : Crowding comparison operator

A solution xi wins over a solution xj , iff any of the following conditions
are true
If solution xi has a better rank (i.e. dominance rank). That is
rank(xi ) < rank(xj )
If they have the same rank but solution xi has better crowding
solution xj .
That is rank(xi ) = rank(xj ) and di > dj (where di and dj are

crowding distance of xi and xj , respectively.

Note :
The first condition ensures that xi lies on a better non-domination

front.
The second condition resolve the tie of both solution being on the
same non-dominated front by deciding on their crowding distances
(Note : For NSGA-II, only the second condition is valid as all solution
are belong to one front only.

Definition 7 : Crowding distance measure

The crowding distance measure di is an estimate of the size of the
largest cuboid enclosing the point xi (i-th solution) without including
any point in the population.

f3
Xi-1
Xi-1
f2
x2 Xi
f1
Xi+1
Xi+1
f1
f2
(a) Solutions in 2D space (b) Solutions in 3D space

In Fig(a), the crowding distance is the average side length of the

rectangle (so that two nearest solutions of xi and xi − 1 at two
opposite corners).
In fig.(b), the crowding distance is the sum of three adjacent

edges of a cuboid formed by the two neighbors xi−1 and xi+1 of xi
at two opposite corners of the cuboid.

Crowding distance calculation
Given a set of non-dominated solutions say F , and objective functions

f = f1 , f2 , · · · , fM , the procedure to calculate the crowding distance of
each solution xi ∈ F is stated below. Steps :
1 Let l = |F | (Number of solutions in F )

2 For each xi nF , set di = 0 (Initialize the crowding distance)
3 For each objective fi ∈ f
F i = sort(F , i)
Sort all solutions in F with respect to objective values fi
This will result F 1 , F 2 , · · · , F m sorted vector.
The sorting is performed in ascending order of objective values fi
The sorted vectors are shown in the fig.

1 2 M
11 21 M1
12 22 M2
1l 2l Ml

1 For each solution j = 2 to l − 1 do
fk∗j+1 −fk∗j−1
dj = M
P
k=1 f MAX −f MIN
k k
2 di = dl =∝(Each boundary solutions are not crowded and hence
large crowded distance)
f27
f26
f25
2
f24
f23
f22
f21
1
f11 f12 f13 f14 f15 f16 f17

Note :
1 All objective function are assumed be minimized

2 Time complexity of the above operation is O(MN log2 N) , is the
complexity of M sorting operation with N elements.
3 The parameters fkMAX and fkMIN , K = 1, 2, · · · M can be set as the
population-maximum and population-minimum values of k-th
objective function and is used here to normalize the objective
values.

Crowding Tournament
Once crowding distance of all solutions in the last acceptable front

F is calculated we are to select N − |P 0 | solutions from F to
complete the size of |P| = N.
To do this, we are to follow tournament selection operation
according to <c (Crowding comparison operator). That is we
select xi over xj (xi <c xj ) if di > dj .
Note that we prefer those solutions which are not in the crowded
search space. This ensure a better population diversity.

Crowding Tournament
Remarks :
NSGA-II is an elitist approach
It consider a faster non-dominated sorting procedure with time

complexity O(MN 2 ) compared to O(MN 3 ) in NSGA.
It does not require explicit sharing concept rather use a crowding

tournament selection with time complexity O(MN log N)
Thus, the overall time complexity of NSGA-II is O(MN 2 )

Solving MOOP_ Pareto-based MOEA Approaches

Uploaded by

Copyright:

Available Formats

Solving MOOP_ Pareto-based MOEA Approaches

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Solving MOOP_ Pareto-based MOEA Approaches

Uploaded by

Copyright:

Available Formats

Solving MOOP: Pareto-based MOEA approaches

Indian Institute of Technology Kharagpur

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 1 / 70

A priori approach A posteriori approach

Ranking and Niching

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 2 / 70

A priori approach A posteriori approach

Ranking and Niching

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 3 / 70

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 4 / 70

It is Pareto-based approach based on the principle of ranking

MOGA follows the following methodologies:

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 5 / 70

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 6 / 70

Definition 6 : Rank of a solution

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 7 / 70

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 8 / 70

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 9 / 70

Number of dominated points

1 Domination count = How many individual does an individual

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 11 / 70

1 Sort the population in ascending order according to their ranks.

This procedure keeps the global population fitness constant while

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 12 / 70

Individual with rank i

Linerization Rank i+1

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 14 / 70

The fitness assignment (Step 3) in MOGA attempts to keep global

MOGA follows blocked fitness assignment which is likely to

MOGA founds to produce better result (near optimal) in majority of

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 15 / 70

J. Horn and N. Nafploitis, 1993 Reference : Multiobjective

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 16 / 70

1 i=1 (The first iteration)

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 18 / 70

4 If C1 is dominated by CS but not by C2 than select C2 as the

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 19 / 70

A sharing is followed, when there is no preference in the

This maintains the genetic diversity allows to develop a

The sharing procedure for any candidate is as follows.

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 20 / 70

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 21 / 70

3 Let σshare = Niched Radius

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 22 / 70

Initial Population of Random Population

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 23 / 70

This approach proposed by Horn and Nafploitis [1993]. The approach

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 24 / 70

S = an array of N individuals in the current population.

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 25 / 70

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 26 / 70

if candidate 1 dominatedand ∼ candidate 2 dominated then

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 28 / 70

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 29 / 70

How you solve two optimization problem

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 30 / 70

N.Srinivas and K.Deb, 1994

The algorithm is based on the concept of

Debasis Samanta (IIT Kharagpur) Soft Computing Applications 29.03.2016 31 / 70

xi - denotes i-th solution