IMPLEMENTACIN DE ALGORITMO DE ESTRATEGIAS EVOLUTIVAS DE LA FORMA

(
+ ) 
Juan Felipe Muoz Fernndez - jfmunozf@unal.edu.co
14-Nov-2014

En cualquier lenguaje de programacin programe un algoritmo de Estrategias Evolutivas o de

Algoritmos Genticos para optimizar la siguiente funcin (Rosenbrock).
n 1

f ( x) = 100( xi2 xi +1 ) 2 + (1 xi ) 2
i =1

n = 2 , 5.12 xi 5.12
Elija los parmetros que considere adecuados.
Grafique la secuencia de bsqueda: iteracin vs mejor f (x)
1. Cul es la mejor solucin x' y f (x' ) encontrada?
En general:
2. Qu ventajas le ve al algoritmo?
3. Qu desventajas le ve al algoritmo?
Debe entregar: diagrama de flujo (o seudocdigo), algoritmo (con comentarios) y resultados.

PSEUDOCDIGO
Inicio
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar

numero de generaciones = K
tamao poblacin =
poblacin de individuos hijos de = 7 *
tamao de paso de la desviacin =
lmite superior dominio variable Xi = 5.12
lmite inferior dominio variable Xi = -5.12
Arreglo poblacin X1 = AleatorioUniforme(,-5.12,5.12)
Arreglo poblacin X2 = AleatorioUniforme(,-5.12,5.12)
desviacin estndar =  =
(5.12 (5.12)/6
en blanco Arreglo desviacin estndar X1
en blanco Arreglo desviacin estndar X2
en blanco Arreglo hijos X1
en blanco Arreglo desviacin estndar hijos X1
en blanco Arreglo hijos X2
en blanco Arreglo desviacin estndar hijos X2
en blanco Arreglo fitness padres
en blanco Arreglo fitness hijos
en blanco Arreglo probabilidad acumulada

Para i = 1 hasta

() = f(poblacin X1[i],poblacin X2[i])
Arreglo fitness padres [i] = AadirElemento(
())
Arreglo desviacin estndar X1[i] =
Arreglo desviacin estndar X2[i] =
Fin-Para
Para k = 1 hasta K
Para i = 1 hasta
Ciclo para inicializar arreglo de desv. Std.
Arreglo probabilidad acumulada[i] = i/
Fin-Para
Para i = 1 hasta
RuletaPadre1 = AleatorioUniforme(1,0,1)
RuletaPadre2 = AleatorioUniforme(1,0,1)
Seleccin
Para j=2 hasta
Ciclo de seleccin de padres
Si (Arreglo probabilidad acumulada[j-1] <=
RuletaPadre1 <= Arreglo probabilidad acumulada[j])
Entonces
Padre1X1 = Arreglo poblacin X1[j]
DesviacionPadre1X1 = Arreglo desviacin estndar
X1[j]
Padre1X2 = Arreglo poblacin X1[j]
DesviacionPadre1X2 = Arreglo desviacin estndar
X1[j]
Fin-Si
Si (Arreglo probabilidad acumulada[j-1] <=
RuletaPadre2 <= Arreglo probabilidad acumulada[j])
Entonces

Padre2X1 = Arreglo poblacin X1[j]

DesviacionPadre2X1 = Arreglo desviacin estndar
X1[j]
Padre2X2 = Arreglo poblacin X1[j]
DesviacionPadre2X2 = Arreglo desviacin estndar
X1[j]
Fin-Si
Fin-Para
Cruzamiento intermedio
HijoX1 = (Padre1X1 + Padre2X1)/2
DesviacionHijoX1 = (DesviacionPadre1X1

DesviacionPadre2X1)/2

HijoX2 = (Padre1X2 + Padre2X2)/2

DesviacionHijoX2 = (DesviacionPadre1X2

DesviacionPadre2X2)/2

Mutacin
DesviacionPerturbadaHijoX1 = DesviacionHijoX1 *  (,,)
DesviacionPerturbadaHijoX2 = DesviacionHijoX1 *  (,,)
HijoX1 = HijoX1 + (1,0,  !"#$"%&'()*(+#,#-".%/ )
HijoX2 = HijoX2 + (1,0,  !"#$"%&'()*(+#,#-".%/0 )
Calculo del fitness del hijo generado

() = f(HijoX1, HijoX2)
Arreglo fitness hijos = AadirElemento(
())
Arreglo hijos X1 = AadirElemento(HijoX1)
Arreglo desviacin estndar hijos X1 =
AadirElemento(DesviacionPerturbadaHijoX1)
Arreglo hijos X2 = AadirElemento(HijoX2)
Arreglo desviacin estndar hijos X2 =
AadirElemento(DesviacionPerturbadaHijoX2)
Fin-Para
Inicializar
Inicializar
Inicializar
Inicializar
Inicializar

en
en
en
en
en

blanco
blanco
blanco
blanco
blanco

Arreglo
Arreglo
Arreglo
Arreglo
Arreglo

(
(
(
(
(

+
+
+
+
+

)X1
)X2
)X1
)X2
) 
()

Juntar padres + hijos

Arreglo ( + )X1 = AadirElemento(Arreglo poblacin X1, Arreglo
hijos X1)
Arreglo ( + )X2 = AadirElemento(Arreglo poblacin X2, Arreglo
hijos X2)

Arreglo ( + )X1 = AadirElemento(Arreglo desviacin estndar

X1, Arreglo desviacin estndar hijos X1)
Arreglo ( + )X2 = AadirElemento(Arreglo desviacin estndar
X2, Arreglo desviacin estndar hijos X2)
Arreglo ( + ) 
() = AadirElemento(Arreglo fitness padres,
Arreglo fitness hijos)
Inicializar
Inicializar
Inicializar
Inicializar

en
en
en
en

blanco
blanco
blanco
blanco

Arreglo
Arreglo
Arreglo
Arreglo

poblacin X1
poblacin X2
desviacin estndar X1
desviacin estndar X2

Seleccin de padres para la siguiente generacin

Para i = 1 hasta
Mejor = 9999
Para j = 1 hasta tamao de arreglo ( + ) 
()
Si ((Arreglo ( + ) 
()[j] <= Mejor) y
(Arreglo ( + ) 
()[j] <> 9999)) Entonces
Mejor = arreglo ( + ) 
()[j]
ndice = j
Fin-Si
Fin-Para
Padres de la siguiente generacin
Arreglo poblacin X1 = AadirElemento(Arreglo ( + )X1
[ndice])
Arreglo poblacin X2 = AadirElemento(Arreglo ( + )X2
[ndice])
Arreglo desviacin estndar X1 = AadirElemento(Arreglo ( +
)X1[Indice]
Arreglo desviacin estndar X2 = AadirElemento(Arreglo ( +
)X2[Indice]
El elemento seleccionado (fitness) se sobre escribe con un
valor atpico para no volverlo a tener en cuenta
Arreglo ( + ) 
()[ndice] = 9999
Fin-Para
Fin-Para
Fin

RESULTADOS
El algoritmo se corri con los siguientes parmetros.
-

Nmero de generaciones (K) = 50

Tamao de la poblacin () = 20 individuos.

Nmero de individuos hijos () = 7 x

Tamao del paso de la desviacin estndar () = 0.02

Los resultados estn indicados en la siguiente tabla. El mejor valor de f(x) en la ltima
generacin.
Tabla 1: Resultados ejecucin algoritmo (
+ ) 
Iteracin
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Mejor X1
Mejor X2
f(x)
0.4112564 -0.2674012
19.40273
1.695582
2.859003 0.5094138
1.695582
2.859003 0.5094138
0.8865207 0.8426046 0.3342046
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9802172
0.948112 0.01655542
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708
0.9981759
1.004901 0.00730708

Iteracin
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

Mejor X1
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435
1.02435

Mejor X2
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137
1.051137

f(x)
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259
0.00093259

De acuerdo a los resultados ilustrador por la Tabla 1, la mejor solucin x' y f (x' ) es la
siguiente:
-

Mejor x1 = 1.024350

Mejor x2 = 1.051137

Mejor f(x) = 0.00093259

GRFICA DEL PROCESO DE BSQUEDA: GENERACIN vs f(x)

La siguiente figura ilustra el proceso de bsqueda del algoritmo para hallar el ptimo de la
funcin f(x) de acuerdo a los resultados de la Tabla 1.
Figura 1: Grfica de generacin vs f(x)

VENTAJAS DEL ALGORITMO

-

Para el caso particular, el algoritmo de Estrategias Evolutivas es el adecuado dado que las
posibles soluciones que optimizan la funcin de Rosenbrock, son continuas y el algoritmo
de ES se desempea mejor con este tipo de variables, a diferencia de los algoritmos
genticos que son ms adecuados con variables continuas o binarias.

Los mejores individuos siempre permanecen vivos en las generaciones, eliminando las
peores soluciones de la poblacin.

Es un algoritmo poblacional, lo que facilita la bsqueda de soluciones en un gran espacio

factible de soluciones.

Combina unas buenas soluciones para obtener unas mejores.

No se queda en ptimos locales.

Los diferentes operadores probabilsticos lo dotan de robustez.

DESVENTAJAS DEL ALGORITMO

-

Dificultad inicial para determinar los parmetros del algoritmo.

Debido a su capacidad de memoria a largo plazo, se hace necesario implementar varias

estructuras de datos con las cuales hay que ser cuidadosos en el manejo de sus ndices.

Su convergencia y calidad de la solucin, depender en gran medida de los parmetros

iniciales. Aunque existen versiones auto adaptativas, este trabajo no incluy este tipo de
variacin del algoritmo.

Puede presentarse convergencia prematura.

Los individuos ms aptos predominan en la poblacin dejando por fuera a individuos

menos aptos restando diversidad a la poblacin que podra enriquecer la calidad de la
bsqueda y solucin.

CDIGO FUENTE EN LENGUAJE R

#
#
#
#
#
#
#
#
#

Implementacion algoritmo Estrategias Evolutivas

de la forma [(mu + lambda) - ES] para optimizacin
de la funcin de Rosenbrock en lenguaje R.
Autor: Juan Felipe Munoz Fernandez
email: jfmunozf@unal.edu.co
Universidad Nacional de Colombia - Sede Medellin
Facultad de Minas
Fecha ultima actualizacion: 13-Nov-2014

# Se define la funcin de Rosenbrock.

# Para la implementacin pedida, la
# la dimensin: n=2, por tal razn el
# ciclo for que implementa la sumatoria
# va hasta 1.
rosenbrock=function(x){
fr = 0
for (i in 1:1){
fr = fr+((100*(((x[i]^2)-x[i+1])^2))+((1-x[i])^2))
}
return (fr)
}
# Numero mximo de generaciones
numIteraciones = 50
# Tamao de la poblacion
mu = 20
# Poblacion de individuos hijos
lambda = 7 * (mu)
# Tamao del paso de la desviacion
deltaSigma = 0.02
# Domino de la variable Xi
limInf = -5.12
limSup = 5.12
# Se inicializa la poblacion de individuos
# para X1 aleatoriamente con distribucion
# uniforme.
poblacionX1 = runif(mu,limInf,limSup)
# Se inicializa la poblacion de individuos
# para X2 aleatoriamente con distribucion
# uniforme.
poblacionX2 = runif(mu,limInf,limSup)
# Se inicializa la desviacion estandar.
# La misma para todos los individuos Xi
# ya que X1 y X2 tienen el mismo dominio.
desvStdInicial = (1/6)*((limSup)-(limInf))

# Se definen dos arreglos para almacenar

# la desviacion estandar de los individuos
# de la poblacion para X1 y X2
dsvSdX1 <- array(1:(mu))
dsvSdX2 <- array(1:(mu))
# Inicializacin en blanco de
# arreglos que se van a usar...
# Arreglo para guardar los hijos generados de X1
hijosX1 = c()
# Arreglo para guardar los hijos generados de X2
hijosX2 = c()
# Arreglo para guardar la desviacion estandar de
# los hijos de X1
sigmaHijosX1 = c()
# Arreglo para guardar la desviacion estandar de
# los hijos de X2
sigmaHijosX2 = c()
# Arreglo para guardar el fitness de los hijos
fitnessHijos = c()
# Arreglo para guardar el fitness de los padres
fitnessPadres = c()
# Este ciclo almacena en los arreglos que
# guardan la desviacion estandar de los
# individuos X1 y X2 la desviacion estandar
# inicial que le corresponde a cada individuo.
# Al principio es la misma para todos.
# Se aprovecha el ciclo para evaluar el fitness
# de los padres generados aleatoriamente.
for (i in 1:(mu)) {
dsvSdX1[i] = desvStdInicial
dsvSdX2[i] = desvStdInicial
# Fitness padres
# Se declara una lista con las variables (X1) y (X2)
# para pasar como argumento a la funcin Rosenbrock
padresXi = c(poblacionX1[i],poblacionX2[i])
# Se pasan los padres Xi a la funcin Rosenbrock
fx = rosenbrock(padresXi)
# Se guarda el Fitness de cada padre en el arreglo
# determinado para esto.
fitnessPadres <- append(fitnessPadres,fx)
}
# Se declara un arreglo para almacenar la probabilidad
# acumulada.
probAcum <- array(1:(mu))

cat(0,poblacionX1[1],poblacionX2[1],rosenbrock(c(poblacionX1[1],poblacionX2[1
])),"\n",file="C:\\datos.csv",sep=",",fill=FALSE,append=TRUE)
# Inicia ciclo de generaciones
for (k in 1:numIteraciones) {
# Ciclo para almacenar la probabilidad acumulada
# de cada padre. Todos los padres tienen igual
# probabilidad de ser seleccionados
for (i in 1:mu) {
probAcum[i] = i/mu
}
# Inicia ciclo de generacion de hijos
for (i in 1:lambda) {
# Los padres se seleccionan tirando un
# numero aleatorio entre 0 y 1 con
# distribucion uniforme. Se necesitan
# dos padres para generar un hijo.
ruletaPadre1 = runif(1,0,1)
ruletaPadre2 = runif(1,0,1)
# Seleccion de padres...
# En este ciclo se seleccionan los padres de la
# poblacion de padres para cada variable de acuerdo
# al valor de la ruletaPadreXi y la probabilidad acumulada.
# La seleccion de los padres debe incluir la desviacin
# estndar de cada uno en cada caso, es decir:
#
Padre1X1,desvStdPadre1X1 + Padre2X1,desvStdPadre2X1 = HijoX1
#
Padre1X2,desvStdPadre1X2 + Padre2X2,desvStdPadre2X2 = HijoX2
for (j in 2:length(probAcum)) {
if ( (ruletaPadre1 >= probAcum[j-1]) && (ruletaPadre1 <=
probAcum[j]) ) {
# Seleccion del padre 1 y su desviacin para X1
padre1X1 = poblacionX1[j]
sigmaPadre1X1 = dsvSdX1[j]
# Seleccion de padre 1 y su desviacin para X2
padre1X2 = poblacionX2[j]
sigmaPadre1X2 = dsvSdX2[j]
}
if ( (ruletaPadre2 >= probAcum[j-1]) && (ruletaPadre2 <=
probAcum[j]) ) {
# Seleccion del padre 2 y su desviacin para X1
padre2X1 = poblacionX1[j]
sigmaPadre2X1 = dsvSdX1[j]
# Seleccion del padre 2 y su desviacin para X2
padre2X2 = poblacionX2[j]
sigmaPadre2X2 = dsvSdX2[j]
}
}
# Cruzamiento intermedio.
# Se cruzan los padres seleccionados con sus

# respectivas desviaciones estandar...

# Se genera el HijoX1
hijoX1 = (padre1X1 + padre2X1)/2
sigmaHijoX1 = (sigmaPadre1X1 + sigmaPadre2X1)/2
# Se genera el HijoX2
hijoX2 = (padre1X2 + padre2X2)/2
sigmaHijoX2 = (sigmaPadre1X2 + sigmaPadre2X2)/2
# Mutacion.
# Se perturba la desviacin estandar de cada HijoXi.
# Mutacion Gaussiana.
sigmaMutadoHijoX1 = sigmaHijoX1 * (exp(rnorm(1,0,deltaSigma)))
sigmaMutadoHijoX2 = sigmaHijoX2 * (exp(rnorm(1,0,deltaSigma)))
# Se perturba el HijoXi teniendo en cuenta la perturbacion
# de la desviacion estandar de cada uno hecha anteriormente.
# Propiamente, estos son los hijos generados.
hijoX1 = hijoX1 + rnorm(1,0,sigmaMutadoHijoX1)
hijoX2 = hijoX2 + rnorm(1,0,sigmaMutadoHijoX2)
# Fitness de los hijos generados.
# Se evala el fitness de los hijos generados.
hijosXi = c(hijoX1,hijoX2)
fx = rosenbrock(hijosXi)
# Se guarda en el arreglo el Fitness
# de los hijos generados.
fitnessHijos <- append(fitnessHijos,fx)
# Se guardan los hijos de X1 y los hijos de X2
# respectivamente en los arreglos indicados.
hijosX1 <- append(hijosX1,hijoX1)
hijosX2 <- append(hijosX2,hijoX2)
# Se guarda la desviacion estndar de los hijos de X1
# y de los hijos de X2 en los arreglos indicados.
sigmaHijosX1 <- append(sigmaHijosX1,sigmaMutadoHijoX1)
sigmaHijosX2 <- append(sigmaHijosX2,sigmaMutadoHijoX2)
}
# Juntar (mu) padres + (lambda) hijos.
# Bloque de arreglos (mu)+(lambda):
# Se inicializan los arreglos en donde
# se van a juntar (mu) padres +(lambda) hijos.
muMasLambdaX1 = c()
muMasLambdaX2 = c()
muMasLambdaSdX1 = c()
muMasLambdaSdX2 = c()
muMasLambdaFitness = c()
# Se juntan (mu) padres + (lambda) hijos de X1
# en un solo arreglo.
muMasLambdaX1 = append(poblacionX1,hijosX1)

# Se juntan (mu) padres + (lambda) hijos de X2

# en un solo arreglo.
muMasLambdaX2 = append(poblacionX2,hijosX2)
# Se juntan la desviacin estndar de
# (mu) padres + (lambda) hijos de X1
# en un solo arreglo.
muMasLambdaSdX1 = append(dsvSdX1,sigmaHijosX1)
# Se juntan la desviacin estndar de
# (mu) padres + (lambda) hijos de X2
# en un solo arreglo.
muMasLambdaSdX2 = append(dsvSdX2,sigmaHijosX2)
# Se juntan los Fitness de los padres y de los hijos en un
# solo arreglo.
muMasLambdaFitness = append(fitnessPadres,fitnessHijos)
# Se preparan los vectores para la siguiente generacion
poblacionX1 = c()
poblacionX2 = c()
dsvSdX1 = c()
dsvSdX2 = c()
#
#
#
#

Seleccion de los mejores padres de esta generacion.

Este bloque de cdigo selecciona los mejores padres
de los arreglos (mu) + (lambda) anteriores.
El criterio de seleccion es el fitness.

# Este primer ciclo repite (mu) veces para seleccionar

# los (mu) mejores individuos de los arreglos (mu)+(lambda)
for (i in 1:mu) {
# Variable de control con un valor atpico
# (fuera del dominio de Xi) para la lgica
# de seleccin del mejor.
mejor = 9999
# Este ciclo recorre el arreglo (mu)+(lambda) seleccionando
# el mejor fitness de todo el arreglo. Cuando lo encuentra
# en esa posicin define un valor atpico para que en la
# proxima iteracin del primer ciclo, este elemento no
# sea tenido en cuenta
for (j in 1:length(muMasLambdaFitness)) {
if ( (muMasLambdaFitness[j] <= mejor) &&
(muMasLambdaFitness[j] != 9999) ) {
mejor = muMasLambdaFitness[j]
indice = j
}
}
# La nueva poblacin de (mu) individuos se va seleccionando
# de los arreglos (mu)+(lambda) respetivos de acuerdo al
# indice de mejor fitness encontrado en el ciclo anterior.
poblacionX1 = append(poblacionX1,muMasLambdaX1[indice])
poblacionX2 = append(poblacionX2,muMasLambdaX2[indice])
dsvSdX1 = append(dsvSdX1,muMasLambdaSdX1[indice])
dsvSdX2 = append(dsvSdX2,muMasLambdaSdX1[indice])

# El mejor fitness encontrado se le asigna un valor atpico

# para no tenerlo en cuenta en la siguiente iteracin.
muMasLambdaFitness[indice] = 9999
}
cat(k,poblacionX1[1],poblacionX2[1],rosenbrock(c(poblacionX1[1],poblacio
nX2[1])),"\n",file="C:\\datos.csv",sep=",",fill=FALSE,append=TRUE)
}

REFERENCIAS
[1]

Jaramillo, G. P. (2014). Computacin Evolutiva II. Estrategia Evolutiva. Evolucin

Diferencial. Sesin 10. Asignatura: Computacin Evolutiva y Optimizacin Heurstica.
Universidad Nacional de Colombia, Medelln.

[2]

Coello Coello, C. A. (2014). Introduccin a la Computacin Evolutiva [en lnea].

CINVESTAV-IPN, Mxico, D.F. http://delta.cs.cinvestav.mx/~ccoello/compevol/clase32014.pdf

[3]

Muoz, M. A. (2008). Estrategias Evolutivas aplicadas a los Algoritmos de Enjambres

para el control de sistemas complejos. Escuela de Ingeniera Elctrica y Electrnica.
Santiago de Cali.

[4]

Lara Lpez, A. (2003). Un estudio de las Estrategias Evolutivas para problemas

Multiobjetivo. CENTRO DE INVESTIGACIN Y DE ESTUDIOS AVANZADOS DEL
INSTITUTO POLITCNICO NACIONAL. Mxico D.F.

[5]

Yu, X., & Gen, M. (2010). Simple Evolutionary Algorithms. Introduction to Evolutionary
Algorithms, 1139. Retrieved from http://link.springer.com/chapter/10.1007/978-1-84996129-5_2

[6]

Dirk Hansen, N., Auger, A., & Auger, A. (2013). Fast evolution strategies. Evolution
Strategies.

ANEXOS
El presente documento PDF incluye los siguientes archivos adjuntos.
-

estrategias-evolutivas.r
Cdigo fuente del algoritmo en lenguaje R.