A Self-Organized Criticality Mutation Operator for Dynamic Optimization Problems

A Self-Organized Criticality Mutation
Operator for Dynamic Optimization
Problems
Carlos Fernandes1,2
J.J. Merelo2
Vitorino Ramos1
Agostinho C. Rosa1
1
LaSEEB-ISR-IST, Technical Univ. of Lisbon (IST), Portugal
2
Department of Architecture and Computer Technology, University of Granada, Spain

Fernandes, Merelo, Ramos and Rosa – “Sandpile Mutation GA” GECCO08 - Atlanta

Motivation and Objectives
•Develop an adaptive mutation operator to deal with
Dynamic Optimization Problems (DOPs).

DOPs require diversity. It is not mandatory that the algorithm
finds the optimum, but, at least, to track it.

We aim at designing a mutation operator which may be able to
give rise to small and large mutation rates in a self-regulated
manner, non-deterministic.
Mutation operator should be able to react to changes, without
detecting those changes. (When a change occurs, mutation
should increase.)
Keep it simple! Avoid new parameters or complex parameter
control.


Self-Organized Criticality
•Self-Organized Criticality was identified by Bak, Tang and
Wiesenfeld in 1987. “The Sandpile” model.

*Image taken from Kauffman’s Investigations

•Cellular automaton.
•“Sand” is randomly dropped on a lattice (2D). When the slope
exceeds a specific threshold (zc = 4), the cell colapses and
transfers the sand to the adjacent cells.


Self-Organized Criticality
•SOC: fractal, scale-invariant, 1/f noise, power-laws
Sandpile: likehood of an avalanche is in power-law proportion to its
size.

Considerer a lattice (x,y) and a function
z(x,y) which represents the number o grains
in the cells.
Starting with a flat surface z(x,y) = 0 for all x
and y:
Add a grain of sand:
if z(x,y) > zc then an avalanche occurs

*Image taken from Kauffman’s Investigations
if z(x, y±1) = 4 or z(x±1, y) = 4
Update z recursively


Previous Related Work
•Tinós, R. and Yang, S. 2007. A self-organizing random immigrants
genetic algorithm for dynamic optimization problems. Genetic
Programming and Evolvable Machines 8, 255-286. SORIGA
• Krink, T., Rickers P., René T. 2000. Applying self-organised criticality to
evolutionary algorithms. Proceedings of the 6th International Conference
on Parallel Problem Solving from Nature, 375-384.
•Boettcher, S., Percus A.G. 2003. Optimization with extremal dynamics.
Complexity 8(2), 57-62.

SORIGA introduces SOC in a GA by simulating a Bak-Sneppen model.


The Sandpile Mutation
The 2D lattice is “connected” with the population
(NxL size, where N is population size and L is
chromosome size)
In each generation g grains are
dropped into the lattice.

Individuals are ranked. This create a
kind of slope for the sandpile, with
sand collapsing with higher probability
towards the worst chromosomes.

If the number of grains in a cell exceed 4, then an avalanche may
occur depending on the fitness of the chromosome.


The Sandpile Mutation
for g grains do
drop grain at random
if zc = 4
compute normalized fitness:

Note: if bestFitness = worstFitness, fn is set to 0.5 (1.0?)

if randomValue(0, 1.0) > fn and cell (n, l) not active
mutate
avalanche

and update lattice z recursively


Test Set Severity of change: This criterion
establishes how strongly the problem is
changing
•Yang and Yao’s dynamic problems generator*
Speed of change: This criterion
•By using a binary mask, dynamic establishes how often the environment
changes
environments are created by applying the
mask to each solution before its evaluation.

•Severity of change is controlled by setting
the number of 1’s in the mask.

•Speed of change is controlled by defining the
number of generations between the application
of a different mask.
*Yang, S. and Yao, X. 2005. Experimental study
on PBIL algorithms for dynamic optimization
problems. Soft Computing 9(11), 815-834.


Test Set
Speed was set to S = 10, 100, 1000 (generations)
Severity was set to ρ = 0.05, 0.6 and 0.95
9 different scenarios

•Royal Road function
•Deceptive functions
•As in: Tinós, R. and Yang, S. 2007. A self-organizing random immigrants genetic
algorithm for dynamic optimization problems. Genetic Programming and
Evolvable Machines 8, 255-286

•Massively Multimodal Deceptive Problem (MMDP)


Test Set
Two-point crossover, pc = 0.7
N = 120
Tournament Selection (Kts = 0.9)

Sand pile Mutation Genetic Algorithm (SMGA)
SMGA: g = 10xL
SMGA (deceptive): g = 50xL

Performance is measured by the mean best-of-generation values, i.e., best
fitness averaged over all generations, and then over all runs
30 runs for each configuration
Compared SMGA with Standard Generational GA (SGA: pm = 1/L) and Random
Immigrants GA (RIGA: rr = 3, rr = 12)


Results – Avalanches and Mutation
MMDP
Avalanches Mutations

L = 24

L = 90


Results

Royal Road Deceptive 1 Deceptive 2

τ ρ SGA RIGA 1 RIGA 2 SMGA SGA RIGA 1 RIGA 2 SMGA* SGA RIGA1 RIGA2 SMGA*

10 0.05
(~) (~) (~) 31.41
(+) (+) (+) 0.855
(~) (+) (+) 0.752

10 0.60
(+) (+) (+) 13.40
(~) (~) (~) 0.793
(+) (+) (~) 0.594

10 0.95
(~) (~) (~) 17.12
(−) (−) (−) 0,922
(+) (~) (−) 0.558

(−) (−) (−) (+) (+) (+) (−) (+) (+)
200 0.05 57.80 0.957 0.7973

(+) (+) (+) (+) (+) (+) (+) (+) (+)
200 0.60 42.15 0.908 0.7832

(+) (+) (+) (−) (−) (−) (+) (+) (+)
200 0.95 46.43 0.939 0.7808

(~) (~) (~) (+) (+) (+) (−) (+) (+)
100
0.05 62.36 0.994 0.79947
0

(~) (~) (~) (+) (+) (+) (+) (+) (+)
100
0.60 54.85 0.984 0.79670
0

(+) (+) (+) (+) (+) (+) (~) (+) (+)
100
0.95 56.62 0.988 0.79623
0


Results

ρ = 0.05 ρ = 0.6 ρ = 0.95

Comparing SGA and SMGA’s dynamic behavior on Royal Road. � = 200


Results – Mutation rate

ρ = 0.05 ρ = 0.6 ρ = 0.95

� = 10


Results – SMGA and SORIGA
3-trap functions (between deception and non-deception): 10
traps, 30 bits
Uniform crossover
pc = 1.0
Binary tournament
Several pm and g values
SORIGA: rr = 3
Speed was set to 2400, 24000, 48000 evaluations
Population size N = 30 and N = 240
Severity was set to ρ = 0.05, 0.3, 0.6 and 0.95
12 different scenarios


N = 30

N = 240


N = 30


Conclusions

SMGA is capable of outperforming SGA and RIGA on a wide
range of problem settings, namely when severity is high.
It is at least competitive with the state-of-the-art SORIGA.
SMGA reacts to changes by increasing mutation rate (the
occurrence of large avalanches is due to a sudden decrease in
the average fitness).
Self-regulated (SOC?), non-deterministic.
Parameter g replaces pm


Future work

Change sandpile structure. Small-world, scale-free
Compare SMGA with SORIGA
Study SMGA response to different g.
Design different DOPs.


A Self-Organized Criticality Mutation Operator for Dynamic Optimization Problems

More Related Content

Similar to A Self-Organized Criticality Mutation Operator for Dynamic Optimization Problems (20)

More from Carlos M. Fernandes (20)

Recently uploaded (20)

A Self-Organized Criticality Mutation Operator for Dynamic Optimization Problems