157 lines
5.1 KiB
Python
157 lines
5.1 KiB
Python
import keyboard as keyboard
|
|
|
|
import field as F
|
|
from ga_methods import *
|
|
from src import mapschema as maps
|
|
|
|
|
|
# Genetic Algorithm
|
|
def genetic_algorithm_setup(field):
|
|
population_units = ["", "w", "p", "s"]
|
|
|
|
# TODO REPREZENTACJA OSOBNIKA - MACIERZ ROZKłADU PLONÓW
|
|
population_text = []
|
|
population_text_single = []
|
|
|
|
population_size = 10
|
|
|
|
# Populate the population_text array
|
|
for k in range(population_size):
|
|
population_text_single = []
|
|
for row in range(D.GSIZE):
|
|
population_text_single.append([])
|
|
for column in range(D.GSIZE):
|
|
population_text_single[row].append(random.choice(population_units))
|
|
population_text.append(population_text_single)
|
|
|
|
"""
|
|
Genetic algorithm parameters:
|
|
Mating pool size
|
|
Population size
|
|
"""
|
|
|
|
# units per population in generation
|
|
best_outputs = []
|
|
num_generations = 100
|
|
num_parents = 4
|
|
|
|
# iterative var
|
|
generation = 0
|
|
stop = 0
|
|
# TODO WARUNEK STOPU
|
|
while generation < num_generations and stop < 3:
|
|
if keyboard.is_pressed('space'):
|
|
generation += 1
|
|
|
|
print("Generation : ", generation)
|
|
# Measuring the fitness of each chromosome in the population.
|
|
|
|
# population Fitness
|
|
fitness = []
|
|
|
|
for i in range(0, population_size):
|
|
fitness.append((i, population_fitness(population_text[i], field, population_size)))
|
|
|
|
print("Fitness")
|
|
print(fitness)
|
|
|
|
best = sorted(fitness, key=lambda tup: tup[1], reverse=True)[0:num_parents]
|
|
|
|
# Leaderboard only
|
|
best_outputs.append(best[0][1])
|
|
|
|
# The best result in the current iteration.
|
|
print("Best result : ", best[0])
|
|
|
|
# TODO METODA WYBORU OSOBNIKA - RANKING
|
|
# Selecting the best parents in the population for mating.
|
|
parents = [population_text[i[0]] for i in best]
|
|
parents_copy = copy.deepcopy(parents)
|
|
print("Parents")
|
|
for i in range(0, len(parents)):
|
|
print('\n'.join([''.join(['{:4}'.format(item) for item in row])
|
|
for row in parents[i]]))
|
|
print("")
|
|
|
|
# Generating next generation using crossover.
|
|
offspring_x = random.randint(1, D.GSIZE - 2)
|
|
offspring_y = random.randint(1, D.GSIZE - 2)
|
|
|
|
# TODO OPERATOR KRZYŻOWANIA
|
|
offspring_crossover = crossover(parents)
|
|
print("Crossover")
|
|
for i in range(0, len(offspring_crossover)):
|
|
print('\n'.join([''.join(['{:4}'.format(item) for item in row])
|
|
for row in offspring_crossover[i]]))
|
|
print("")
|
|
|
|
# TODO OPERATOR MUTACJI
|
|
offspring_mutation = mutation(population_units, offspring_crossover, population_size - num_parents,
|
|
num_mutations=10)
|
|
print("Mutation")
|
|
for i in range(0, len(offspring_mutation)):
|
|
print('\n'.join([''.join(['{:4}'.format(item) for item in row])
|
|
for row in offspring_mutation[i]]))
|
|
print("")
|
|
|
|
population_text_copy = copy.deepcopy(population_text)
|
|
unused_indexes = [i for i in range(0, population_size) if i not in [j[0] for j in best]]
|
|
# Creating next generation
|
|
population_text = []
|
|
for k in parents_copy:
|
|
population_text.append(k)
|
|
for k in range(0, len(offspring_mutation)):
|
|
population_text.append(offspring_mutation[k])
|
|
while len(population_text) < population_size:
|
|
x = random.choice(unused_indexes)
|
|
population_text.append(population_text_copy[x])
|
|
unused_indexes.remove(x)
|
|
|
|
# TODO WARUNEK STOPU
|
|
stop = 0
|
|
if generation > 10:
|
|
if best_outputs[-1] / best_outputs[-2] < 1.001:
|
|
stop += 1
|
|
if best_outputs[-1] / best_outputs[-3] < 1.001:
|
|
stop += 1
|
|
if best_outputs[-2] / best_outputs[-3] < 1.001:
|
|
stop += 1
|
|
|
|
# final Fitness
|
|
fitness = []
|
|
for i in range(0, population_size):
|
|
fitness.append((i, population_fitness(population_text[i], field, population_size)))
|
|
|
|
print("Final Fitness")
|
|
print(fitness)
|
|
|
|
best = sorted(fitness, key=lambda tup: tup[1])[0:num_parents]
|
|
|
|
print("Best solution : ", )
|
|
for i in range(0, D.GSIZE):
|
|
print(population_text[best[0][0]][i])
|
|
print("Best solution fitness : ", best[0][1])
|
|
|
|
pretty_printer(best_outputs)
|
|
|
|
# TODO REALLY return best iteration of field
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
# Define the map of the field
|
|
mapschema = maps.createField()
|
|
|
|
# Create field array
|
|
field = []
|
|
|
|
# Populate the field array
|
|
for row in range(D.GSIZE):
|
|
field.append([])
|
|
for column in range(D.GSIZE):
|
|
fieldbit = F.Field(row, column, mapschema[column][row])
|
|
field[row].append(fieldbit)
|
|
|
|
genetic_algorithm_setup(field)
|