def __init__(self, individuals: List = None):
if individuals is None:
self.individuals: List[Genome] = [
Genome() for _ in range(Const.N_INDIVIDUALS)
]
else:
self.individuals: List[Genome] = individuals
def linear_crossover(genome_1: Genome, genome_2: Genome) -> Genome:
a: float = rd.uniform(0, 1)
new_genes = (genome_1.genes * a + (1 - a) * genome_2.genes)
for i in range(len(new_genes)):
new_genes[i] = round(new_genes[i], 0)
return Genome(new_genes)
def multi_point_crossover(genome_1: Genome, genome_2: Genome) -> Genome:
num_of_points = randint(0, const.GENOME_LENGTH)
selection = rd.choices([0, 1], weights=[5, 5], k=1)
new_genes = []
multi_points = []
for i in range(num_of_points):
multi_points.append(randint(0, const.GENOME_LENGTH))
# remove duplicate variables from the list
multi_points = list(dict.fromkeys(multi_points))
multi_points.sort()
counter = 0
if selection[0] == 0:
for i in range(const.GENOME_LENGTH):
if i >= multi_points[counter]:
counter += 1
if counter % 2 == 0:
new_genes.append(genome_1.genes[i])
else:
new_genes.append(genome_2.genes[i])
else:
for i in range(const.GENOME_LENGTH):
if i >= multi_points[counter]:
counter += 1
if counter % 2 == 0:
new_genes.append(genome_2.genes[i])
else:
new_genes.append(genome_1.genes[i])
return Genome(new_genes)
def old_old_load_file_and_show_graph(file_name):
f = open(file_name, )
data = json.load(f)
pop_data = dict(data['population'])
colors = plt.get_cmap('plasma')(np.linspace(0, 0.8, len(Room.rooms)))
x = np.arange(len(pop_data))
avg_fitness = []
best_fitness = []
diversity = []
room_data = {i: [] for i in range(len(Room.rooms))}
for generation in data['population']:
c_data = data['population'][generation]
genes = [Genome(genes=g['genes']) for g in c_data['individuals']]
population = Population(genes)
individual_fitness = [g['fitness'] for g in c_data['individuals']]
diversity.append(population.compute_diversity())
best_fitness.append(np.max(individual_fitness))
avg_fitness.append(np.mean(individual_fitness))
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle('Genetic Algorithm - Fitness - 1 Room')
ax1.plot(x, avg_fitness, color="blue", label="AVG Fitness")
ax1.plot(x, best_fitness, color="green", label="Best Fitness")
leg1 = interactive_legend(ax1)
ax2.plot(x, diversity, color="red", label='diversity')
leg3 = interactive_legend(ax2)
plt.show()
def load_file_and_show_graph(file_name):
f = open(file_name, )
data = json.load(f)
pop_data = dict(data['population'])
colors = plt.get_cmap('plasma')(np.linspace(0, 0.8, len(Room.rooms)))
x = np.arange(len(pop_data))
avg_fitness = []
best_fitness = []
diversity = []
room_data = {i: [] for i in range(len(Room.rooms))}
room_names = [
'Empty', 'Triangle', 'Room', 'Small Box', 'Bigger Box', 'Trapezoid',
'Labyrinth', 'Propeller', 'Slope'
]
for generation in data['population']:
c_data = data['population'][generation]
genes = [Genome(genes=g['genes']) for g in c_data['individuals']]
population = Population(genes)
individual_fitness = [g['fitness'] for g in c_data['individuals']]
for room_idx in range(len(Room.rooms)):
room_data[room_idx].append(
np.mean([
individual_fitness[i][str(room_idx)]
for i in range(len(individual_fitness))
]))
generall_fitness = [
np.mean(list(individual_fitness[i].values()))
for i in range(len(individual_fitness))
]
diversity.append(population.compute_diversity())
best_fitness.append(np.max(generall_fitness))
avg_fitness.append(np.mean(generall_fitness))
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle('Genetic Algorithm - Fitness - Random Rooms')
ax1.plot(x, avg_fitness, color="blue", label="AVG Fitness")
ax1.plot(x, best_fitness, color="green", label="Best Fitness")
# ax1.plot(x, diversity, color="red")
leg1 = interactive_legend(ax1)
ax3 = ax1.twinx()
ax3.plot(x, diversity, color="red", label='diversity')
leg3 = interactive_legend(ax3)
max_length = np.max([len(ro_data) for ro_data in room_data.values()])
for key, ro_data in room_data.items():
ax2.plot(np.arange(len(ro_data)),
ro_data,
color=colors[key],
label=room_names[key])
leg2 = interactive_legend(ax2)
plt.show()
def uniform_crossover(genome_1: Genome, genome_2: Genome) -> Genome:
new_genes = []
for i in range(const.GENOME_LENGTH):
selection = rd.choices([0, 1], weights=[5, 5], k=1)
if selection[0] == 0:
new_genes.append(genome_1.genes[i])
else:
new_genes.append(genome_2.genes[i])
return Genome(new_genes)
def one_point_crossover(genome_1: Genome, genome_2: Genome) -> Genome:
first_point = randint(0, const.GENOME_LENGTH)
new_genes = []
for i in range(const.GENOME_LENGTH):
if first_point < i:
new_genes.append(genome_1.genes[i])
else:
new_genes.append(genome_2.genes[i])
return Genome(new_genes)
def load_generation(self, generation):
loaded_data = self.sim_data['population'][str(generation)]
genes = [
Genome(genes=g['genes'], fitness=g['fitness'])
for g in loaded_data['individuals']
]
population = Population(genes)
if self.show_best is not None:
population.get_top(self.show_best)
self.c_seed = loaded_data['seed']
return population
def two_point_crossover(genome_1: Genome, genome_2: Genome) -> Genome:
first_point = randint(0, const.GENOME_LENGTH)
# Normally both have to be a random number but it makes sense to start them that way since after the 1st point then the second starts
second_point = randint(first_point, const.GENOME_LENGTH)
new_genes = []
selection = rd.choices([0, 1], weights=[5, 5], k=1)
if selection[0] == 0:
for i in range(const.GENOME_LENGTH):
if i < first_point or i > second_point:
new_genes.append(genome_1.genes[i])
else:
new_genes.append(genome_2.genes[i])
else:
for i in range(const.GENOME_LENGTH):
if i < first_point or i > second_point:
new_genes.append(genome_2.genes[i])
else:
new_genes.append(genome_1.genes[i])
return Genome(new_genes)
def generate_new(self, next_population):
while len(next_population) < Const.N_INDIVIDUALS:
next_population.append(Genome())
def arithmetic_crossover(genome_1: Genome, genome_2: Genome) -> Genome:
new_genes = []
for i in range(const.GENOME_LENGTH):
new_genes.append((genome_1.genes[i] + genome_2.genes[i]) / 2)
return Genome(new_genes)
def avg_data(folder):
runs = listdir(folder)
data_list = []
for run in runs[:2]:
f = open(f'{folder}/{run}', )
data = json.load(f)
pop_data = dict(data['population'])
data_list.append(pop_data)
colors = plt.get_cmap('plasma')(np.linspace(0, 0.8, len(Room.rooms)))
x = np.arange(len(pop_data))
sum_avg_fitness = []
up_std_error_avg_fitness = []
down_std_error_avg_fitness = []
sum_best_fitness = []
up_std_error_best_fitness = []
down_std_error_best_fitness = []
sum_diversity = []
up_std_error_diversity = []
down_std_error_diversity = []
sum_room_data = {i: [] for i in range(len(Room.rooms))}
room_names = [
'Empty', 'Triangle', 'Room', 'Small Box', 'Bigger Box', 'Trapezoid',
'Labyrinth', 'Propeller', 'Slope'
]
for gen in range(100):
avg_fitness = []
best_fitness = []
diversity = []
room_data = {i: [] for i in range(len(Room.rooms))}
for data_entry in data_list:
c_data = data_entry[str(gen)]
genes = [Genome(genes=g['genes']) for g in c_data['individuals']]
population = Population(genes)
individual_fitness = [g['fitness'] for g in c_data['individuals']]
for room_idx in range(len(Room.rooms)):
room_data[room_idx].append(
np.mean([
individual_fitness[i][str(room_idx)]
for i in range(len(individual_fitness))
]))
generall_fitness = [
np.mean(list(individual_fitness[i].values()))
for i in range(len(individual_fitness))
]
diversity.append(population.compute_diversity())
best_fitness.append(np.max(generall_fitness))
avg_fitness.append(np.mean(generall_fitness))
avg_of_avg_fitness = np.mean(avg_fitness)
sum_avg_fitness.append(avg_of_avg_fitness)
differences = []
for c_avg_fitness in avg_fitness:
differences.append(avg_of_avg_fitness - c_avg_fitness)
up_std_error_avg_fitness.append(
np.max(avg_fitness) - avg_of_avg_fitness)
down_std_error_avg_fitness.append(avg_of_avg_fitness -
np.min(avg_fitness))
avg_of_best_fitness = np.mean(best_fitness)
sum_best_fitness.append(avg_of_best_fitness)
differences = []
for c_best_fitness in avg_fitness:
differences.append(avg_of_best_fitness - c_best_fitness)
up_std_error_best_fitness.append(
np.max(best_fitness) - avg_of_best_fitness)
down_std_error_best_fitness.append(avg_of_best_fitness -
np.min(best_fitness))
avg_diversity = np.mean(diversity)
sum_diversity.append(avg_diversity)
differences = []
for c_diversity in diversity:
differences.append(avg_diversity - c_diversity)
up_std_error_diversity.append(np.max(diversity) - avg_diversity)
down_std_error_diversity.append(avg_diversity - np.min(diversity))
for room_idx in range(len(Room.rooms)):
sum_room_data[room_idx].append(np.mean(room_data[room_idx]))
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle('Genetic Algorithm - Fitness - Avg Rooms')
# ax1.errorbar(x, sum_avg_fitness, [down_std_error_avg_fitness, up_std_error_avg_fitness], color="blue", marker = '^', label='avg_fitness')
# # ax1.plot(x, sum_avg_fitness, color="blue")
# ax1.errorbar(x, sum_best_fitness, [down_std_error_best_fitness, up_std_error_best_fitness], color = "green", marker = 'x', label='best_fitness')
# # ax1.plot(x, sum_best_fitness, color="green")
# leg1 = interactive_legend(ax1)
ax3 = ax1.twinx()
ax3.errorbar(x,
sum_diversity,
[down_std_error_diversity, up_std_error_diversity],
color="red",
marker='^',
label='diversity')
# ax3.plot(x, sum_diversity, color="red", label='diversity')
leg3 = interactive_legend(ax3)
for key, ro_data in sum_room_data.items():
ax2.plot(np.arange(len(ro_data)),
ro_data,
color=colors[key],
label=room_names[key])
leg2 = interactive_legend(ax2)
plt.show()