Estoy aprendiendo acerca de los algoritmos genéticos y con el fin de entender mejor los conceptos que he intentado construir algoritmo genético desde cero utilizando Python sin usar ningún módulo externo (sólo la biblioteca estándar y un poco de numpy)
El objetivo es encontrar una cadena de destino, por lo que si le doy la cadena hola y definir 26 caracteres + un espacio, hay 26 ^ 5 posibilidades, que es enorme. Por lo tanto la necesidad de utilizar un algoritmo genético para resolver este problema tomando.
He definido las siguientes funciones:
Generar población : generamos el tamaño de la población n dado y un objetivo que generamos n Cadena tener len(target)de caracteres aleatorios, volvemos a la población como una lista de str
Calcular una puntuación de fitness : si el carbón en la posición ies igual a la carbonización en la posición i de la meta incrementamos la puntuación, aquí está el código:
def fitness(indiv,target):
score = 0
#print(indiv," vs ",target)
for idx,char in enumerate(list(target)):
if char == indiv[idx]:
score += 1
else:
score = 0
return score
Seleccione los padres, que cruzan entre los padres y la generación de una nueva población de niños
Aquí son la función responsable de lo siguiente:
from numpy.random import choice
def crossover(p1,p2):
# we define a crossover between p1 and p2 (single point cross over)
point = random.choice([i for i in range (len(target))])
#print("Parents:",p1,p2)
# C1 and C2 are the new children, before the cross over point they are equalt to their prantes, after that we swap
c = [p1[i] for i in range(point)]
#print("Crossover point: ",point)
for i in range(point,len(p1)):
c.append(p2[i])
#print("Offsprings:", c1," and ", c2)
c = "".join(c)
# we mutate c too
c = mutate(c)
return c
def mutate(ind):
point = random.choice([i for i in range (len(target))])
new_ind = list(ind)
new_ind[point] = random.choice(letters)
return "".join(new_ind)
def select_parent(new_pop,fit_scores):
totale = sum(fit_scores)
probs = [score/totale for score in fit_scores]
parent = choice(new_pop,1,p=probs)[0]
return parent
Estoy seleccionando los padres mediante el cálculo de las probabilidades de cada individuo (puntuación individual / puntuación total de la población), a continuación, utilizando una elección aleatoria ponderada de funciones para seleccionar uno de los padres (esto es una función numpy).
Para el cruce, estoy generando un niño cy un punto de división al azar, todos los caracteres antes de este punto al azar son los primeros caracteres de los padres, y todos los caracteres después del punto de división son caracteres de la matriz.
además de eso he definido una función llamada should_stop cuales comprobación de si nos encontramos en el blanco, y print_best que consiga los mejores individuos de una población (puntuación más alta de fitness).
Entonces creé una función de búsqueda que utilizan todas las funciones definidas anteriormente:
def find(size,target,pop):
scores = [fitness(ind,target) for ind in pop]
#print("len of scores is ", len(scores))
#good_indiv = select_individuals(pop,scores)
#print("Length of good indivs is", len(good_indiv))
new_pop = []
# corssover good individuals
for ind in pop:
pa = select_parent(pop,scores)
pb = select_parent(pop,scores)
#print(pa,pb)
child = crossover(pa,pb)
#print(type(child))
new_pop.append(child)
best = print_best(new_pop,scores)
print("********** The best individual is: ", best, " ********")
return (new_pop,best)
n = 200
target = "hello"
popu = generate_pop(n,target)
#find(n,target,popu)
for i in range(1000):
print(len(popu))
data = find(n,target,popu)
popu = data[0]
print("iteration number is ", i)
if data[1] == target:
break
El Problema El problema es que está tomando demasiadas iteraciones de Ha de hacerse para generar hola (más de 200 iteraciones mayor parte del tiempo), mientras que en este ejemplo, sólo se necesitan unas pocas iteraciones: https://jbezerra.github.io/ el Shakespeare-y-mono-Problema / index.html
Que el problema no está codificado de la misma manera, he utilizado pitón y una forma de procedimiento para las cosas de código, pero la lógica es la misma. Entonces, ¿qué estoy haciendo mal?
Usted mutar 100% del tiempo. Selecciona los padres '' adecuados que puedan producir una descendencia en forma, pero luego se aplica una mutación que es más probable que no "echar fuera". El enlace de ejemplo proporcionadas sus comporta del mismo modo que si aumenta la tasa de mutación a 100%.
El propósito de la mutación es la de "empujar" la búsqueda en una dirección diferente si parece estar atrapado en un óptimo local, aplicando todo el tiempo se vuelve esto desde un algoritmo evolutivo para algo mucho más cercano a la búsqueda aleatoria.