Entrega

Author: tikissmikiss

ga.py

@@ -4,23 +4,46 @@
 import sys
 import random
 import re
-from math import sqrt
 from math import ceil
 
 
 _password = "Abre. Soy yo! Quién va a ser si no?"
 
-
+###############################################################################
 # Opciones de ejecucion
+###############################################################################
 _pop_size = 100
 _elite_rate = 0.2
 _mutate_prob = 0.8
 _max_generations = 10000
-_verbose = True
-_print_all = True
-_static_print = True
+_verbose, _print_all, _static_print = True, False, True
 _version = 0 if os.path.split(__file__)[-1] == os.path.split(sys.argv[0])[-1] else sys.argv[0][-4]
-
+for arg in sys.argv[1:]:
+    if re.compile('^-[vasVAS]+').search(arg):
+        if 'v' in arg: _verbose = True
+        if 'V' in arg: _verbose = False
+        if 'a' in arg: _print_all = True
+        if 'A' in arg: _print_all = False
+        if 's' in arg: _static_print = True
+        if 'S' in arg: _static_print = False
+    elif re.compile('^--pop-size=[-\+\d]+').search(arg): _pop_size = int(arg.split('=')[1])
+    elif re.compile('^--elite-rate=[-\+\d]+').search(arg): _elite_rate = float(arg.split('=')[1])
+    elif re.compile('^--mutate-prob=[-\+\d]+').search(arg): _mutate_prob = float(arg.split('=')[1])
+    elif re.compile('^--max-generations=[-\+\d]+').search(arg): _max_generations = int(arg.split('=')[1])
+    elif re.compile('^--password=.+').search(arg): _password = arg.split('=')[1]
+    elif re.compile('^[^-]{2}.+').search(arg): _password = arg
+    elif re.compile('^--verbose=[\d]+').search(arg): _verbose = bool(int(arg.split('=')[1]))
+    elif re.compile('^--all=[\d]+').search(arg): _print_all = bool(int(arg.split('=')[1]))
+    elif re.compile('^--static=[\d]+').search(arg): _static_print = bool(int(arg.split('=')[1]))
+    elif re.compile('^--version=[-\+\d]+').search(arg) and os.path.split(__file__)[-1] == os.path.split(sys.argv[0])[-1]: _version = arg.split('=')[1]
+if sum([1 for i in [_elite_rate, _mutate_prob, _pop_size, _max_generations] if i < 0]):
+    sys.exit("Error: Invalid parameters")
+
+
+
+###############################################################################
+# Metodos aportados por el profesor (No se modifican)
+###############################################################################
 
 def get_password_len():
     """ Return the length of the current password, for simulation purposes """
@@ -37,75 +60,53 @@ def gene_set():
     return " 0123456789áéíóúabcdefghijklmnñopqrstuvwxyzÁÉÍÓÚABCDEFGHIJKLMNÑOPQRSTUVWXYZ!\"#$%&\'()*+,-./:;<=>¿?@[\\]^_`{|}"
 
 
-def procese_options():
-    global _password, _pop_size, _elite_rate, _mutate_prob, _max_generations, _verbose, _print_all, _static_print, _version
-    # if ('--verbose') in sys.argv: _verbose = True
-    # if ('--all') in sys.argv: _print_all = True
-    # if ('--static') in sys.argv: _static_print = True
-    for arg in sys.argv[1:]: 
-        if re.compile('^-[vasVAS]+').search(arg):
-            if 'v' in arg: _verbose = True
-            if 'V' in arg: _verbose = False
-            if 'a' in arg: _print_all = True
-            if 'A' in arg: _print_all = False
-            if 's' in arg: _static_print = True
-            if 'S' in arg: _static_print = False
-        elif re.compile('^--pop-size=[-\+\d]+').search(arg): _pop_size = int(arg.split('=')[1])
-        elif re.compile('^--elite-rate=[-\+\d]+').search(arg): _elite_rate = float(arg.split('=')[1])
-        elif re.compile('^--mutate-prob=[-\+\d]+').search(arg): _mutate_prob = float(arg.split('=')[1])
-        elif re.compile('^--max-generations=[-\+\d]+').search(arg): _max_generations = int(arg.split('=')[1])
-        elif re.compile('^--password=.+').search(arg): _password = arg.split('=')[1]
-        elif re.compile('^[^-]{2}.+').search(arg): _password = arg
-        elif re.compile('^--verbose=[\d]+').search(arg): 
-            _verbose = bool(int(arg.split('=')[1]))
-        elif re.compile('^--all=[\d]+').search(arg): 
-            _print_all = bool(int(arg.split('=')[1]))
-        elif re.compile('^--static=[\d]+').search(arg): 
-            _static_print = bool(int(arg.split('=')[1]))
-        elif re.compile('^--version=[-\+\d]+').search(arg) and os.path.split(__file__)[-1] == os.path.split(sys.argv[0])[-1]: 
-            _version = arg.split('=')[1]
-    if sum([1 for i in [_elite_rate, _mutate_prob, _pop_size, _max_generations] if i < 0]):
-        sys.exit("Error: Invalid parameters")
-
-
-procese_options()
 
+###############################################################################
+# Implementación metodos solicitados por el profesor
+###############################################################################
 
 def initial_population(pop_size, chromosome_len):
     """ Create a initial population """
-    # return [random.sample(gene_set(), chromosome_len) for _ in range(pop_size)]
-    # sample devuelve conjuntos de k elementos sin elementos repetidos
-    return [[random.choice(gene_set()) for _ in range(chromosome_len)] for _ in range(pop_size)]
+    population = []
+    for _ in range(pop_size):
+        population.append( ''.join(random.choice(gene_set()) for _ in range(chromosome_len)))
+    return [[i, get_fitness(i)] for i in population]
 
 
-# Implemente la función mutate() que recibe un cromosoma y lo muta cambiando aleatoriamente un único gen por otro del gene_set().
 def mutate(chromosome):
     """ Mutate randomly one gen of the chromosome, which is a string with the characters of the password """
-    chromosome[random.randint(0, len(chromosome) - 1)] = random.choice(gene_set())
+    pos = random.randint(0, get_password_len() - 1)
+    chromosome[0] = chromosome[0][:pos] + random.choice(gene_set()) + chromosome[0][pos+1:]
+    chromosome[1] = get_fitness(chromosome[0])
     return chromosome
 
 
-# Implemente la función crossover() que recibe 2 cromosomas, realiza con ellos una hibridación de 1 punto aleatorio, y devuelve otro cromosoma con la hibridación realizada.
 def crossover(chromosome1, chromosome2):
     """ Perform a one point crossover of the chromosomes """
     if random.random() < 0.5: chromosome1, chromosome2 = chromosome2, chromosome1
     split = random.randint(0, get_password_len() - 1)
-    return chromosome1[:split] + chromosome2[split:]
+    hybrid = chromosome1[0][:split] + chromosome2[0][split:]
+    return [hybrid, get_fitness(hybrid)]
 
 
 def ga(pop_size=_pop_size, elite_rate=_elite_rate, mutate_prob=_mutate_prob, max_generations=_max_generations, fun_next_gen=None):
     """ Genetic Algorithm driving the search of the password """
     pop = initial_population(pop_size, get_password_len())
     for i in range(max_generations):
-        pop.sort(key=get_fitness)
+        pop.sort(key=lambda x: x[1])
         print_generation(elite_rate, mutate_prob, the_fitest=pop[0], generation=i+1, pop=pop)
-        if get_fitness(pop[0]) == 0:
-            return pop[0]
+        if pop[0][1] == 0:
+            return pop[0][0]
         pop = fun_next_gen(pop, pop_size, elite_rate, mutate_prob)
     print("Password not found")
     return False
 
 
+
+###############################################################################
+# Metodos propios
+###############################################################################
+
 def _clear():
     if os.name == "nt": os.system("cls") 
     else: os.system("clear")
@@ -116,58 +117,53 @@ def print_generation(elite_rate, mutate_prob, the_fitest, generation, pop):
     if _verbose: 
         print("Version:", _version, "\nPassword length:", get_password_len(),
               "\npop_size:", len(pop), "\nelite_rate:", elite_rate, "\nmutate_prob:", mutate_prob,
-              "\n\nGeneration:", generation, "best-fitness:", get_fitness(the_fitest),
-              "\n", ''.join(the_fitest))
+              "\n\nGeneration:", generation, "best-fitness:", the_fitest[1],
+              "\n", the_fitest[0])
     else: 
-        print("Generation:", generation, " best-fitness:", get_fitness(the_fitest),
-              '  ', ''.join(the_fitest), sep=" ")
+        print("Generation:", generation, " best-fitness:", the_fitest[1],
+              '  ', the_fitest[0], sep=" ")
     if not _static_print and _verbose and not _print_all: print("-"*80)
     if _print_all: 
         print("\nListado ordenado de fitness de toda la poblacion:")
-        print(*['{0:{width}}'.format(get_fitness(i), width=2) for i in pop], sep=" ")
+        print(*['{0:{width}}'.format(i[1], width=2) for i in pop], sep=" ")
     if not _static_print and _print_all: print("-"*80)
 
 
-# def chromosome_to_string(chromosome):
-#     """ Return the string representation of the chromosome """
-#     return "".join(chromosome)
-
-
 def roulette(players, num_winers=1):
     """ Return the winners of the roulette wheel selection """
-    selection_mode = num_winers < len(players)/2
-    players = players.copy()
-    players.sort(key=get_fitness, reverse=selection_mode)
+    selection_mode = num_winers < len(players)/2 # True si es mejor seleccionar que eliminar
+    players = players.copy() # Evitar modificar la lista original
+    players.sort(key=lambda x: x[1], reverse=selection_mode)
     winners = [] if selection_mode else players
     for _ in range(num_winers if selection_mode else len(players) - num_winers):
         domain = gauss_form(len(players))
         tirada = random.randint(1, domain)
-        if selection_mode:
-            winners.append(players.pop(ceil(inverse_gauss_form(tirada))-1))
-        else:
-            winners.pop(ceil(inverse_gauss_form(tirada))-1)
-    return winners if len(winners) > 1 else winners[0]
+        if selection_mode: winners.append(players.pop( winner(tirada) ))
+        else: winners.pop( winner(tirada) )
+    return winners if num_winers != 1 else winners[0]
 
 
 def gauss_form(n):
     """ Return the sum of 1..n natural numbers """
     return (n*(n+1)) // 2
 
 
-def inverse_gauss_form(x):
+def inverse_gauss_form(a):
     """ Return the inverse function of the gauss_sum """
-    return ((8*x+1)**0.5 - 1) / 2
+    return ((8*a+1)**0.5 - 1) / 2
+
+
+def winner(value):
+    """ Return the winner of the roulette wheel selection """
+    return ceil( inverse_gauss_form(value) ) - 1
 
+###############################################################################
+# Selección de versión
+###############################################################################
 
-# print("os.path.split(__file__)[-1] == os.path.split(sys.argv[0])[-1]", os.path.split(__file__)[-1] == os.path.split(sys.argv[0])[-1])
-# print("   __file__", __file__ )
-# print("sys.argv[0]", sys.argv[0])
-# print("sys.argv", sys.argv)
 if os.path.split(__file__)[-1] == os.path.split(sys.argv[0])[-1]:
     if _version: 
         exec(open('ga_v{}.py'.format(_version)).read())
-        # print("os.execv(sys.executable,  sys.argv):")
-        # os.execv(sys.executable,  [sys.argv[0], [sys.argv[1:]]])
     else:
         print("\nEjecute el archivo correspondiente de la versión, o indique la versión que dese ejecutar.", 
               "Ejemplos:",

ga_v1.py

@@ -2,21 +2,19 @@
 
 import random
 
-from ga import ga, crossover, mutate
+from ga import ga, crossover, mutate, roulette
 
 
 def next_generation(pop, pop_size, elite_rate, mutate_prob):
     """ Return the next generation """
-    pop = pop[:2] if pop_size*elite_rate<3 else pop[:int(pop_size*elite_rate)]  # Selecciona la elite
+    pop = pop[:max(2, int(pop_size*elite_rate))]  # Selecciona la elite, mínimo 2
     while len(pop) < pop_size:  # Cruzar elite hasta completar la población
-        couple = random.sample(pop, 2)
+        couple = roulette(pop, 2)
         pop.append(crossover(couple[0], couple[1]))
-    # Mutar la poblacion segun la probabilidad de mutate_prob
-    pop = [mutate(pop[i]) if random.random() < mutate_prob else pop[i]
-           for i in range(len(pop))]
+    # Mutar la población según la probabilidad de mutate_prob
+    pop = [mutate(pop[i]) if random.random() < mutate_prob else pop[i] for i in range(len(pop))]
     return pop
 
 
-gpassword = ga(#pop_size=100, elite_rate=0.2, mutate_prob=0.8,
-               fun_next_gen=next_generation)
+gpassword = ga(fun_next_gen=next_generation)
 print("Fin version 1")

ga_v2.py

@@ -7,10 +7,11 @@
 
 def next_generation(pop, pop_size, elite_rate, mutate_prob):
     """ Return the next generation """
-    split = int(pop_size * elite_rate) # Selecciona la elite
+    split = min(pop_size-2, int(pop_size * elite_rate)) # Selecciona la elite (maximo pop_size-2)
     elite, non_elite = pop[:split], pop[split:]
     # Mutar entre los no elite
-    non_elite = [non_elite[i] if random.random() > mutate_prob else mutate(non_elite[i]) for i in range(len(non_elite))]
+    for i in non_elite:
+        if random.random() > mutate_prob: mutate(i)
     # Cruzar para generar descendencia. Se cruza por parejas en orden para cruzar individuos de similar fitness
     progeny = [crossover(pop[i], pop[i+1]) for i in range(0, pop_size, 2)]
     return elite + roulette(non_elite + progeny, num_winers=pop_size - len(elite))

ga_v3.py

@@ -8,12 +8,12 @@
 
 def next_generation(pop, pop_size, elite_rate, mutate_prob):
     """ Return the next generation """
-    split = int(pop_size * elite_rate)
+    split = min(pop_size-2, int(pop_size * elite_rate)) # (maximo pop_size-2)
     elite, non_elite = pop[:split], pop[split:] # Selecciona la elite
     progeny = []
     for i in elite:
         if random.random() < mutate_prob: mutate(i)
-        else: progeny.append(crossover(i, elite[random.randint(0, len(elite) - 1)]))
+        else: progeny.append(crossover(i, roulette(non_elite)))
     return elite + roulette(non_elite + progeny, num_winers=pop_size - len(elite))
 
 

ga_v4.py

@@ -7,15 +7,14 @@
 
 def next_generation(pop, pop_size, elite_rate, mutate_prob):
     """ Return the next generation """
-    elite = pop[:int(pop_size * elite_rate)]  # Selecciona la elite
-    progeny = elite
-    while len(progeny) < pop_size:
+    elite = pop[:max(2, int(pop_size*elite_rate))]  # Selecciona la elite, mínimo 2
+    nextgen = elite
+    while len(nextgen) < pop_size:
         parent1, parent2 = roulette(elite), roulette(pop)
-        # pop.remove(parent2)
         child = crossover(parent1, parent2)
-        if random.random() < mutate_prob: child = mutate(child)
-        progeny.append(child)
-    return progeny
+        if random.random() < mutate_prob: mutate(child)
+        nextgen.append(child)
+    return nextgen
 
 
 gpassword = ga(#pop_size=100, elite_rate=0.8, mutate_prob=0.2,

ga_v5.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+import random
+
+from ga import ga, crossover, mutate, roulette
+
+
+def next_generation(pop, pop_size, elite_rate, mutate_prob):
+    """ Return the next generation """
+    split = max(10, int(pop_size*elite_rate)) 
+    elite, non_elite = pop[:split], pop[split:]  # Selecciona la elite
+    nextgen = elite.copy()
+    to_cross = []
+    while len(elite) > 0:
+        i = roulette(elite)
+        if random.random() < mutate_prob: nextgen.append(mutate(i.copy()))
+        else: to_cross.append(i)
+        elite.remove(i)
+    if len(to_cross) % 2 == 1: to_cross.append(roulette(non_elite))
+    while len(to_cross) > 0:
+        parent1, parent2 = roulette(to_cross, 2)
+        nextgen.append(crossover(parent1, parent2))
+        to_cross.remove(parent1)
+        to_cross.remove(parent2)
+    return nextgen + roulette(non_elite, pop_size - len(nextgen))
+
+
+gpassword = ga(fun_next_gen=next_generation)
+print("Fin version 5")

ga_v6.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+import random
+
+from ga import ga, crossover, mutate, roulette
+
+
+def next_generation(pop, pop_size, elite_rate, mutate_prob):
+    """ Return the next generation """
+    nextgen = pop[:int(pop_size*elite_rate)]  # Selecciona la elite
+    parents = roulette(pop, random.randint(0, pop_size))
+    while len(parents) > 2:
+        parent1, parent2 = roulette(parents, 2)
+        parents.remove(parent1)
+        parents.remove(parent2)
+        child = crossover(parent1, parent2)
+        if random.random() < mutate_prob: mutate(child)
+        nextgen.append(child)
+    return nextgen + roulette(pop, pop_size - len(nextgen))
+
+
+gpassword = ga(fun_next_gen=next_generation)
+print("Fin version 6")