3

UNIVERSIDAD POLITCNICA SALESIANA

MATERIA

SIMULACIN



NOMBRE

JONATHAN BLADIMIR ARANA MORA
SIMULACIN DE
ALGORITMOS GENTICOS
08/05/2014








4



ndice de contenidos
1 NOMBRE DEL PROYECTO ............................................................................................................. 5
2 OBJETIVOS ....................................................................................................................................... 6
3 JUSTIFICACION ............................................................................................................................... 6
4 ALCANCE .......................................................................................................................................... 6
5 MARCO TEORICO ............................................................................................................................ 7
6 METODOLOGIA ............................................................................................................................. 11
7 CONCLUSIONES Y RECOMENDACIONES ................................................................................ 16
8 REFERENCIAS BIBLIOGRAFICAS .............................................................................................. 16



















5

1 NOMBRE DEL PROYECTO

SIMULACIN DE
ALGORITMOS
GENETICOS
6


2 OBJETIVOS
Objetivo General:

Simular los algoritmos genticos en el lenguaje de programacin Python.
Objetivos Especficos:

Investigar sobre los algoritmos genticos.
Utilizar diagramas UML para la modelacin del algoritmo.
Implementar el algoritmo gentico.
3 JUSTIFICACION
El siguiente documento se realiza por motivos de aprendizaje, especficamente sobre cmo
se puede simular un algoritmo gentico, para la industria que fuera como plantas
medicamentos, gentica, etc. Los mismos que son muy importantes para ver el
comportamiento dependiendo de un estmulo o mutacin para luego proceder a su
aprobacin o desecho.

4 ALCANCE
La aplicacin programada en lenguaje Python se basa en el ingreso de la poblacin
inicial que se lo hace de forma randomica y de 4 binarios, cada uno de estos va a ser un
individuo, luego pasa a la funcin de calidad en la cual se evalua con el peso, luego de esto
se produce el cruce mediante el operador and, para luego mutarlo cogiendo de este cruce un
binario aleatorio para luego terminar conla evaluacin del nuevo individuo.
jaranaInvitado

7

5 MARCO TEORICO
Los Algoritmos Genticos (AGs) son mtodos adaptativos que pueden usarse
para resolver problemas de bsqueda y optimizacin. Estn basados en el
proceso gentico de los organismos vivos. A lo largo de las generaciones,
las poblaciones evolucionan en la naturaleza de acorde con los principios
de la seleccin natural y la supervivencia de los ms fuertes, postulados por
Darwin. Por imitacin de este proceso, los Algoritmos Genticos son capaces
de ir creando soluciones para problemas del mundo real. La evolucin de
dichas soluciones hacia valores ptimos del problema depende en buena
medida de una adecuada codificacin de las mismas.

Un algoritmo gentico consiste en una funcin matemtica o una rutina de
software que toma como entradas a los ejemplares y retorna como salidas
cules de ellos deben generar descendencia para la nueva generacin.

Versiones ms complejas de algoritmos genticos generan un ciclo iterativo
que directamente toma a la especie (el total de los ejemplares) y crea una
nueva generacin que reemplaza a la antigua una cantidad de veces
determinada por su propio diseo. Una de sus caractersticas principales es la
de ir perfeccionando su propia heurstica en el proceso de ejecucin, por lo
que no requiere largos perodos de entrenamiento especializado por parte del
ser humano, principal defecto de otros mtodos para solucionar problemas,
como los Sistemas Expertos.

Los principios bsicos de los Algoritmos Genticos fueron
establecidos por Holland, y se encuentran bien descritos en varios textos .
Goldberg, Davis, Michalewicz, Reeves.

En la naturaleza los individuos de una poblacin compiten entre s en
la bsqueda de recursos tales como comida, agua y refugio. Incluso los
miembros de una misma especie compiten a menudo en la bsqueda de un
compaero. Aquellos individuos que tienen ms xito en sobrevivir y en
atraer compaeros tienen mayor probabilidad de generar un gran nmero de
descendientes. Por el contrario individuos poco dotados producirn un menor
jaranaInvitado

8
nmero de descendientes. Esto significa que los genes de los individuos mejor
adaptados se propagarn en sucesivas generaciones hacia un nmero de
individuos creciente. La combinacin de buenas caractersticas provenientes
de diferentes ancestros, puede a veces producir descendientes
"superindividuos", cuya adaptacin es mucho mayor que la de cualquiera de
sus ancestros. De esta manera, las especies evolucionan logrando unas
caractersticas cada vez mejor adaptadas al entorno en el que viven.

Los Algoritmos Genticos usan una analoga directa con el
comportamiento natural. Trabajan con una poblacin de individuos, cada uno
de los cuales representa una solucin factible a un problema dado. A cada
individuo se le asigna un valor puntuacin, relacionado con la bondad de
dicha solucin. En la naturaleza esto equivaldra al grado de efectividad de un
organismo para competir por unos determinados recursos. Cuanto mayor sea
la adaptacin de un individuo al problema, mayor ser la probabilidad de que
el mismo sea seleccionado para reproducirse, cruzando su material gentico
con otro individuo seleccionado de igual forma. Este cruce producir nuevos
individuos . descendientes de los anteriores . los cuales comparten algunas de
las caractersticas de sus padres. Cuanto menor sea la adaptacin de un
individuo, menor ser la probabilidad de que dicho individuo sea seleccionado
para la reproduccin, y por tanto de que su material gentico se propague en
sucesivas generaciones.

De esta manera se produce una nueva poblacin de posibles
soluciones, la cual reemplaza a la anterior y verifica la interesante
propiedad de que contiene una mayor proporcin de buenas caractersticas
en comparacin con la poblacin anterior. As a lo largo de las
generaciones las buenas caractersticas se propagan a travs de la poblacin.
Favoreciendo el cruce de los individuos mejor adaptados, van siendo
exploradas las reas ms prometedoras del espacio de bsqueda. Si el
Algoritmo Gentico ha sido bien diseado, la, poblacin converger hacia una
solucin ptima del problema.
Ventajas y Desventajas

jaranaInvitado

9
No necesitan conocimientos especficos sobre el problema que
intentan resolver.

Operan de forma simultnea con varias soluciones, en vez de
trabajar de forma secuencial como las tcnicas tradicionales.
Cuando se usan para problemas de optimizacin maximizar
una funcin objetivo- resultan menos afectados por los
mximos locales (falsas soluciones) que las tcnicas
tradicionales.
Resulta sumamente fcil ejecutarlos en las modernas
arquitecturas masivamente paralelas.
Usan operadores probabilsticos, en vez de los tpicos
operadores determinsticos de las otras tcnicas.
Pueden tardar mucho en converger, o no converger en absoluto,
dependiendo en cierta medida de los parmetros que se utilicen
tamao de la poblacin, nmero de generaciones, etc.-.
Pueden converger prematuramente debido a una serie de
problemas de diversa ndole.
Limitaciones
El poder de los Algoritmos Genticos proviene del hecho de que se trata de una
tcnica robusta, y pueden tratar con xito una gran variedad de problemas
provenientes de diferentes reas, incluyendo aquellos en los que otros mtodos
encuentran dificultades. Si bien no se garantiza que el Algoritmo Gentico
encuentre la solucin ptima, del problema, existe evidencia emprica de que se
encuentran soluciones de un nivel aceptable, en un tiempo competitivo con el resto
de algoritmos de optimizacin combinatoria. En el caso de que existan tcnicas
especializadas para resolver un determinado problema, lo ms probable es que
superen al Algoritmo Gentico, tanto en rapidez como en eficacia. El gran campo
de aplicacin de los Algoritmos Genticos se relaciona con aquellos problemas
para los cuales no existen tcnicas especializadas. Incluso en el caso en que dichas
tcnicas existan, y funcionen bien, pueden efectuarse mejoras de las mismas
hibridndolas con los Algoritmos Genticos.

Como Saber si es Posible usar un Algoritmo Gentico

La aplicacin ms comn de los algoritmos genticos ha sido la solucin de
problemas de optimizacin, en donde han mostrado ser muy eficientes y confiables.
jaranaInvitado

10
Sin embargo, no todos los problemas pudieran ser apropiados para la tcnica, y se
recomienda en general tomar en cuenta las siguientes caractersticas del mismo
antes de intentar usarla:

Su espacio de bsqueda (i.e., sus posibles soluciones) debe estar
delimitado dentro de un cierto rango.
Debe poderse definir una funcin de aptitud que nos indique qu tan
buena o mala es una cierta respuesta.
Las soluciones deben codificarse de una forma que resulte
relativamente fcil de implementar en la computadora.

El primer punto es muy importante, y lo ms recomendable es intentar resolver
problemas que tengan espacios de bsqueda discretos aunque stos sean muy
grandes. Sin embargo, tambin podr intentarse usar la tcnica con espacios de
bsqueda continuos, pero preferentemente cuando exista un rango de soluciones
relativamente pequeo.

La funcin de aptitud no es ms que la funcin objetivo de nuestro problema de
optimizacin. El algoritmo gentico nicamente maximiza, pero la minimizacin
puede realizarse fcilmente utilizando el recproco de la funcin maximizante (debe
cuidarse, por supuesto, que el recproco de la funcin no genere una divisin por
cero). Una caracterstica que debe tener esta funcin es que tiene ser capaz de
"castigar" a las malas soluciones, y de "premiar" a las buenas, de forma que sean
estas ltimas las que se propaguen con mayor rapidez.

La codificacin ms comn de las soluciones es a travs de cadenas binarias, aunque se
han utilizado tambin nmeros reales y letras. El primero de estos esquemas ha gozado
de mucha popularidad debido a que es el que propuso originalmente Holland, y adems
porque resulta muy sencillo de implementar.

PROBLEMTICA
El problema de la mochila propiamente dicho consiste en, teniendo una mochila que
puede aguantar cierto peso mximo, meter objetos en ella hasta que se agote su
capacidad. Cada objeto tiene un valor y un peso. Hay varias maneras de meter los
objetos:
jaranaInvitado

11
Empezar metiendo desde los de menos peso hasta los de mayor. Asi podremos
introducir un mayor nmero de objetos.
Empezar metiendo desde los de ms valor hasta los de menos. As vamos
aumentando ms rpidamente el valor de los objetos que contiene la mochila.
Introducirlos por orden, de mayor a menor valor por unidad de peso.

6 METODOLOGIA

DIAGRAMA UML
DIAGRAMA DE ESTADOS


Cdigo Fuente
Producto
'''

@author: jarana
'''
class Producto(object):
'''
classdocs
'''


def __init__(self, id_, rng, peso = None, beneficio = None):
'''
Constructor
jaranaInvitado

12
'''

self.id = id_
self.beneficio = beneficio

self.peso = rng.randint(0, 1000) if peso is None else peso # Aleatorio
self.beneficio = rng.randint(0, 500) if beneficio is None else beneficio # Aleatorio

def __str__(self):
return self.__repr__()

def __repr__(self):
return 'Producto(id = {0}, peso = {1}, beneficio = {2})'.format(self.id, self.peso, self.beneficio)

Poblacion
'''

@author: jarana
'''
import mochila
Mochila = mochila.Mochila

class Poblacion(object):
# Iniciamos la poblacion aleatoriamente
def __init__(self, productos, rnd, capacidad, n = 50, Pc = 0.9, Pm = 0.2):
# productos: tupla de productos
# rnd: generador de pseudo-azar
# capacidad: capacidad de la mochila
# Pc: probabilidad de cruza
# Pm: probabilidad de mutacion
# n: tamao de la poblacion

self.container = []
self.rand = rnd
self.Pc = Pc
self.Pm = Pm
self.n = n

self.mutaciones = 0
self.cruzas = 0
self.generaciones = 0

for i in range(n):
m = Mochila(i, productos, capacidad, rnd)
m.aleatorizar()
self.container.append(m)
self.container.sort(key = lambda mochila: mochila.beneficio, reverse = True) # Asi deberian salir
mas rapidito las mejores soluciones
# Tambien sirve para irme piteando las peores soluciones

# Esto es para calculos de la ruleta
def totalBeneficio(self):
return sum(m.beneficio for m in self.container)

# La famosa ruleta ...
def ruleta(self):
total = float(self.totalBeneficio())
dado = self.rand.random()
jaranaInvitado

13

suma = 0
for m in self.container:
suma += m.beneficio / total
if suma >= dado: # Llegamos al wilson, the chosen one
break
return m # Retornamos la mochila elegida al azar

# Avanza una etapa de evolucion
def newGeneration(self):
self.generaciones += 1
coqueta1 = self.ruleta()
coqueta2 = self.ruleta()

nos_cruzamos = self.rand.random()
if nos_cruzamos <= self.Pc: # Se cruzan 1313
self.cruzas += 1
h1, h2 = mochila.cruza(coqueta1, coqueta2)
del self.container[-2:] # Nos piteamos a los dos wilsons mas wilsons de la poblacion
muta = self.rand.random()
if muta <= self.Pm: # Mutamos a la hija1
self.mutaciones += 1
mochila.mutar(h1)
muta = self.rand.random()
if muta <= self.Pm: # Mutamos a la hija2
self.mutaciones += 1
mochila.mutar(h2)
self.container.extend([h1, h2]) # Y agregamos a los hijos recien creados
self.container.sort(key = lambda mochila: mochila.beneficio, reverse = True) # De nuevo, sorting
...

# Retornamos al mejor wilson de la poblacion
def mejorWilson(self):
return self.container[0]

def __repr__(self):
return 'Poblacion(mochilas: {0}; generaciones: {1}; mutaciones: {2}; cruzas: {3}\nMejor mochila:
{4}'.format(self.n, self.generaciones, self.mutaciones, self.cruzas, self.mejorWilson())

def __str__(self):
return self.__repr__()

Mochila
'''

@author: jarana
'''
class Mochila(object):
def __init__(self, id_, productos, capacidad, rnd):

self.id = id_
self.productos = productos
self.capacidad = capacidad
self.rand = rnd
self.info = [False] * len(self.productos) # Por defecto no se lleva ningun producto en la mochila!

def __repr__(self):
return 'Mochila(peso = {2}, beneficio = {3})'.format(self.id, self.info, self.peso, self.beneficio)
jaranaInvitado

14

def __str__(self):
return self.__repr__()
# Getter para peso
def __getPeso(self):
return sum((producto.peso for producto in self.productos if self.info[producto.id])) # Sumamos si
esta en la mochila

# Getter para beneficio
def __getBeneficio(self):
return sum((producto.beneficio for producto in self.productos if self.info[producto.id])) # Sumamos
si esta en la mochila

# Genera solucion aleatoria
def aleatorizar(self):
productos = list(self.productos)
self.rand.shuffle(productos)

while productos:
prod = productos.pop()

if prod.peso <= (self.capacidad - self.peso):
self.info[prod.id] = True

# Repara la solucion si es invalida
def reparar(self):
while self.peso > self.capacidad: # Si nos pasamos del rango de peso ...
idx = self.rand.randrange(0, len(self.productos))
self.info[idx] = False

# Propertys
peso = property(fget = __getPeso)
beneficio = property(fget = __getBeneficio)

# Realiza una 'cruza' de mochilas
def cruza(mochila1, mochila2):
# Vemos en que posicion cortamos las mochilas, permutamos las mitades y voila! tenemos dos
soluciones hijas
corte = mochila1.rand.randrange(0, len(mochila1.info))

productos = mochila1.productos
capacidad = mochila1.capacidad

# Construyo las hijas
hija1 = Mochila(mochila1.id + 1, productos, capacidad, mochila2.rand)
hija2 = Mochila(mochila2.id + 1, productos, capacidad, mochila1.rand)

# Ahora cruzo los adn
hija1.info = mochila1.info[:corte] + mochila2.info[corte:]
hija2.info = mochila2.info[:corte] + mochila1.info[corte:]

# Ahora las reparo ...
hija1.reparar()
hija2.reparar()

return hija1, hija2

# Muta una solucion
def mutar(mochila):
adn_mutado = mochila.info[:]
jaranaInvitado

15

hebra = mochila.rand.randrange(0, len(mochila.info))
adn_mutado[hebra] = not adn_mutado[hebra]

mut = Mochila(mochila.id, mochila.productos, mochila.capacidad, mochila.rand)
mut.info = adn_mutado
mut.reparar()

return mut

MochilaGenetica
'''

@author: jarana
'''
import random
import itertools
from producto import Producto
from poblacion import Poblacion
from mochila import Mochila

if __name__ == '__main__':
cant_productos = 17
capacidad = 3570
generaciones = 10000
n = 60
rnd = random.Random(6352)

productos = tuple(Producto(i, rnd) for i in range(cant_productos)) # Lista de productos generados
aleatoriamente

pob = Poblacion(productos, rnd, capacidad, n)
print ('-' * 50)
print ("Mejor mochila poblacion inicial:")
print (pob)
print ('-' * 50)
print()

for _ in range(generaciones):
pob.newGeneration()

print ('-' * 50)
print ("Mejor mochila ".format(generaciones))
print (pob)
print ('-' * 50)
print()

# # Fuerza bruta!
mejol = Mochila(0, productos, capacidad, rnd) # Mochila vacia :(

for idx, info in enumerate(itertools.product([True,False], repeat = cant_productos)):
m = Mochila(idx, productos, capacidad, rnd)
m.info = info
if m.beneficio > mejol.beneficio and m.peso <= capacidad: # Solucion mejor
mejol = m
print ("Resultado")
print (mejol)

jaranaInvitado

16

Resultado

7 CONCLUSIONES Y RECOMENDACIONES
Para evaluar la funcin de calidad de los individuos se puede realizar por
varias parmetros diferentes como los ms grandes, ms inteligentes, etc.
En el cruce podemos usar funciones lgicas como and, or , nand, nor
vlidas para poder realizar el cruce.
La mutacin depende de la lgica que se introduzca podemos mutar hasta
un porcentaje del individuo cruzado.

8 REFERENCIAS BIBLIOGRAFICAS
http://eddyalfaro.galeon.com/geneticos.html

M. Domnguez-Dorado,. Todo Programacin. N 12. Pgs. 16-20. Editorial
Iberprensa (Madrid). DL M-13679-2004. Septiembre, 2005.. Programacin de
algoritmos genticos..

D. Whitley, T. Starkweather, D. Shaner (1991). The traveling salesman
and sequence scheduling:

Quality solutions using genetic edge recombination, en Davis, L. (ed.)
Handbook of Genetic Algorithms, Van Nostrand Reinhold, New York, 350-372

http://taylor.us.es/componentes/miguelangel/algoritmosgeneticos.pdf

http://www.redcientifica.com/gaia/ce/agsp_c.htm

http://webdiis.unizar.es/jcampos/EDA/ea/slides/9-Algoritmos %20geneticos.pdf