SI_2020/genetic_algorithm.py

151 lines
5.3 KiB
Python
Raw Normal View History

import random
import math
### prawdopodobieństwo mutacji
2020-05-11 11:53:55 +02:00
mutation_prob = 0.03
### ilość osobników w pokoleniu, powinna być parzysta
2020-05-11 11:53:55 +02:00
generation_size = 20
### liczba pokoleń
2020-05-11 11:53:55 +02:00
number_of_generations = 30
### liczba paczek
2020-05-11 11:53:55 +02:00
number_of_packages = 45
### liczba regałów
2020-05-11 11:53:55 +02:00
number_of_racks = 70
### jak bardzo promowane są osobniki wykorzystujące całą pojemność regału
amount_of_promotion = 3
def first_gen():
first_generation = []
for individual in range(generation_size):
individual = []
for pack in range(number_of_packages):
r = random.randint(0,number_of_racks-1)
individual.append(r)
first_generation.append(individual)
return first_generation
def evaluation(individual):
# im większy fitness tym lepszy osobnik
# print("regały: ",racks)
rest_of_capacity = racks.copy()
# print("początkowa pojemność: ",rest_of_capacity)
for i in range(number_of_packages):
rest_of_capacity[individual[i]] -= packages[i]
# print("pozostała pojemność: ",rest_of_capacity)
fitness = 0
for i in range(number_of_racks):
# jak regał jest przepełniony, zmniejsza fitness osobnika
if rest_of_capacity[i] < 0:
fitness += rest_of_capacity[i]
# delikane promowanie osobników wykorzystujących regały w pełni
elif rest_of_capacity[i] == 0:
fitness += amount_of_promotion
### tu dodaj to co zrobi Andrzej
return fitness
def roulette(generation):
# print('pokolenie: ', generation)
evaluations = []
for i in range(generation_size):
individual_fitness = evaluation(generation[i])
evaluations.append(individual_fitness)
# print("tablica dopasowań: ", evaluations)
maximum = min(evaluations)
# dodaję tą 1 żeby nie wywalać najgorszego osobnika
normalized = [x+(-1*maximum)+1 for x in evaluations]
# print(normalized)
sum_of_normalized = sum(normalized)
roulette_tab = [x/sum_of_normalized for x in normalized]
# print(roulette_tab)
for i in range(1,generation_size-1):
roulette_tab[i] += roulette_tab[i-1]
# wpisuję 1 ręcznie, bo czasem liczby nie sumowały się idealnie do 1
#(niedokładność komputera)
roulette_tab[generation_size-1] = 1
# print("ruletka: ", roulette_tab)
survivors = []
for individual in range(generation_size):
random_number = random.random()
interval_number = 0
while random_number > roulette_tab[interval_number]:
interval_number += 1
survivors.append(generation[interval_number])
# print('przetrwali: ',survivors)
return survivors
def crossover(individual1, individual2):
cut = random.randint(1,number_of_packages-1)
new1 = individual1[:cut]
new2 = individual2[:cut]
new1 = new1 + individual2[cut:]
new2 = new2 + individual1[cut:]
# print(individual1)
# print(individual2)
# print(new1)
# print(new2)
# print(cut)
return new1, new2
def mutation(individual):
# print(individual)
locus = random.randint(0,number_of_packages-1)
individual[locus] = random.randint(0,number_of_racks-1)
return individual
2020-05-11 11:53:55 +02:00
def gen_alg(number_of_generations, generation_size, mutation_prob, amount_of_promotion):
### WŁAŚCIWY ALGORYTM
generation = first_gen()
global_maximum = -math.inf
2020-05-11 11:53:55 +02:00
# pętla znajdująca najlepszy fitness w pierwszym pokoleniu
for i in range(generation_size):
evaluation_of_individual = evaluation(generation[i])
if evaluation_of_individual > global_maximum:
global_maximum = evaluation_of_individual
best_individual = generation[i].copy()
2020-05-11 11:53:55 +02:00
#właściwa pętla programu
for generation_index in range(number_of_generations):
print('pokolenie numer: ', generation_index)
# print(generation)
2020-05-11 11:53:55 +02:00
### RULETKA
survivors = roulette(generation)
# print('przetrwali: ',survivors)
2020-05-11 11:53:55 +02:00
### KRZYŻOWANIE
descendants = []
for individual in range(0,generation_size,2):
pair = crossover(survivors[individual],survivors[individual+1])
for each in pair:
descendants.append(each)
# print('potomkowie: ', descendants)
2020-05-11 11:53:55 +02:00
### MUTACJA
for individual in range(generation_size):
if random.random() <= mutation_prob:
mutation(descendants[individual])
# print('potomkowie po mutacji: ', descendants)
### NAJLEPSZE DOPASOWANIE
local_maximum = -math.inf
for each in range(generation_size):
specific_fitness = evaluation(descendants[each])
if specific_fitness > local_maximum:
local_maximum = specific_fitness
print('maximum w pokoleniu: ',local_maximum)
if local_maximum > global_maximum:
global_maximum = local_maximum
generation = descendants
print('maximum globalne: ', global_maximum)
### lista paczek, indeks to id paczki, wartość w liście to jej waga
packages = [random.randint(1,10) for i in range(number_of_packages)]
### lista regałów, indeks to id regału, wartość w liście to jego pojemność
racks = [random.randint(15,18) for i in range(number_of_racks)]
# print(packages)
# print(racks)
gen_alg(number_of_generations, generation_size, mutation_prob, amount_of_promotion)