def find_best_route(self, **kwargs):
# uruchomienie algorytmu szukającego optymalnej ścieżki
if not self.cities or not self.connections or not self.salesman_max_time:
self.info_message(
'Do uruchomienia algorytmu niezbędne są informacje o miastach, połączeniach między nimi '
'oraz czasie pracy komiwojażera')
return
# ponieważ często czas pracy algorytmu jest duży (liczony w sekundach) to blokowane są przyciski,
# aby użytkownik nic nie zrobił
self.block_buttons()
try:
# próba wyznaczenia optymalnej ścieżki
algorithm = GeneticAlgorithm(self.cities, self.connections,
self.salesman_max_time)
print('#', self.connections)
best_route = algorithm.find_optimal_route(
**kwargs) # zapisanie znalezionej ścieżki
self.unblock_buttons() # odblokowanie przycisków
for city in best_route.route:
print(city, best_route.cities[city].id)
for city_coordinates in best_route.get_route_coordinates():
print(city_coordinates)
except Exception as e:
# wyświetlenie informacji o błędzie podczas pracy algorytmu
self.unblock_buttons()
self.error_message(
f'Wystąpił błąd podczas szukania optymalnej trasy: {e}')
return
self.solution = self.parse_route_for_solution(best_route)
def test_construct_cities(self):
cities = GeneticAlgorithm.construct_cities(self.cities, self.connections)
assert cities == {'Miasto1': City('Miasto1', 1, 1, 5), 'Miasto2': City('Miasto2', 2, 2, 4),
'Miasto3': City('Miasto3', 2, 2, 6)}
assert cities['Miasto1'].connected_cities == {'Miasto2': 2}
assert cities['Miasto2'].connected_cities == {'Miasto1': 2}
assert cities['Miasto3'].connected_cities == dict()
def GaAnimate(bitlen=7):
x = np.linspace(0,1,1<<bitlen)
y = np.linspace(0,1,1<<bitlen)
X,Y = np.meshgrid(x,y)
Z = randfunc(X, Y)
ga = GA(Z,bitlen=bitlen)
ga_seq = ga.evolve()
sequence = []
for seq in ga_seq:
mask = (1 << bitlen) - 1
x = seq & mask
mask <<= bitlen
y = (seq & mask) >> bitlen
sequence.append([x,y])
GaAnimator = animator(X,Y,Z,sequence,fig=2,name="GA",interval=10)
GaAnimator.render()
def resynthesize(reference_pcm_audio):
Spectrogram(reference_pcm_audio.samples).to_tga_file(
"reference_spectrogram.tga")
algorithm = GeneticAlgorithm()
best_score = None
pcm_audio = None
sounds = []
if os.path.exists("base.wav"):
print "Using 'base.wav' as a base sound for additive sythesis"
pcm_audio = PcmAudio.from_wave_file("base.wav")
for index in xrange(20):
genome_factory = get_sound_factory(reference_pcm_audio, pcm_audio)
population = Population(genome_factory, 80)
best_sound = algorithm.run(population)
if best_score is not None and best_sound.score < best_score:
print "The algorithm failed to produce a better sound on this step"
break
print best_sound
pcm_audio = best_sound.to_pcm_audio()
pcm_audio.to_wave_file("debug%d.wav" % index)
Spectrogram(pcm_audio.samples).to_tga_file()
best_score = best_sound.score
sounds.append(best_sound)
construct_csound_file(sounds, pcm_audio)
return pcm_audio
def check_solution(self):
# metoda sprawdzająca czy rozwiązanie jest prawidłowe
if self.salesman_max_time is None:
# wyświetlenie komunikatu o błędzie jeśli czas pracy komiwojażera nie został wczytany
self.info_message('Wczytaj najpierw czas pracy Komiwojażera')
return
if not self.solution:
# wyświetlenie komunikatu o błędzie jeśli rozwiązanie nie zostało wczytane lub wyznaczone
self.error_message('Brak wczytanego lub obliczonego rozwiązania')
return
if not self.cities or not self.connections:
# do weryfikacji poprawności trasy potrzebujemy listy miast i połączeń między nimi
self.info_message(
'Do weryfikacji poprawności trasy niezbędne są: lista miast oraz połączeń między nimi'
)
return
# przekształcamy trasę rozwiązania do postaci obiektu Route
cities = GeneticAlgorithm.construct_cities(
self.cities, self.connections) # najpierw tworzymy miasta
solution_cities = [city[0] for city in self.solution
] # wybieramy tylko id miast trasy rozwiązania
route = Route(solution_cities, cities) # tworzymy obiekt Route
if route.is_valid(self.salesman_max_time):
# jeżeli rozwiązanie jest poprawne to poinformowanie o tym użytkownika
self.info_message('Trasa jest poprawna')
elif route.invalid_cause == 'less than 2 cities':
# poinformowanie użytkownika, że rozwiązanie jest błędne, bo ma mniej niż 2 miasta
self.info_message('Trasa składa się z mniej niż dwóch miast')
elif route.invalid_cause == 'cities not connected':
# poinformowanie użytkownika, że rozwiązanie jest błędne, bo nie jest możliwe połączenie miast na trasie
self.info_message(
'Na trasie sąsiadują ze sobą miasta, które nie są ze sobą połączone'
)
elif route.invalid_cause == 'too long':
# poinformowanie użytkownika, że rozwiązanie jest błędne, bo pokonanie trasy przekracza czas pracy
# komiwojażera
self.info_message(
'Długość trasy przekracza ograniczenie Komiwojażera')
else:
# poinformowanie, że trasa nie jest poprawna z innego powodu
self.info_message('Trasa nie jest poprawna')
def run(self):
""" Run the Genetic Algorithm
"""
self.problem.counter = Counter(self.nEvals)
self.stats.setLabel("GA---" + self.parameters + "[" +
str(self.nEvals) + "]")
print("\n Experiments to GA")
for e in range(self.nExperim):
print(" " + str(e), self.problem.nVar)
GA = GeneticAlgorithm(self.problem, self.parameters)
self.stats.add(GA.stateFinal)
self.problem.counter = Counter(self.nEvals)
print("\n")
self.stats.prints()
print("")
self.stats.printAllSolutions()
def save_solution(self, filename):
# metoda zapisująca rozwiązanie do pliku filename jeśli rozwiązanie istnieje
# w przeciwnym razie poinformowanie użytkownika, że rozwiązanie nie zostało wyznaczone lub wczytane
if not self.solution:
self.error_message('Brak rozwiązania, które można zapisać')
return
if not self.connections:
self.error_message(
'W celu zapisania rozwiązania niezbędne są dane miast')
return
if not self.cities:
self.error_message(
'W celu zapisania rozwiązania niezbędne są dane połączeń między miastami'
)
return
# przekształcenie do wymaganego formatu
solution = [[str(element) for element in city]
for city in self.solution]
route_string = [','.join(city) for city in solution]
route_string = [f'({city})' for city in route_string]
route_string = ','.join(route_string)
route_string = f'[{route_string}]'
cities = GeneticAlgorithm.construct_cities(self.cities,
self.connections)
solution_cities = [city[0] for city in self.solution
] # wybieramy tylko id miast
route = Route(solution_cities, cities)
data = '\r\n'.join(
[route_string,
str(route.fitness),
str(route.distance)])
# upewniamy się, że nazwa pliku, który zapisujemy ma rozszerzenie .txt i dodajemy jeśli nie ma
if not filename.endswith('.txt'):
filename += '.txt'
IO.save_solution(data, filename)
def __init__(self, config):
self.config = config
self.map = Map(self.config)
self.algorithm = GeneticAlgorithm(self.config)
self.generate_initial_population()
class Simulation:
def __init__(self, config):
self.config = config
self.map = Map(self.config)
self.algorithm = GeneticAlgorithm(self.config)
self.generate_initial_population()
def generate_initial_population(self):
"""
Generate random population of n chromosomes (suitable solutions for the problem)
Creates a random genome
"""
random.seed()
self.population = []
for chromosome in range(self.config['population_size']):
# create a random chromosome with a random gain value
self.population.append(Chromosome(
random.random() * self.config['max_gain_value'],
random.random() * self.config['max_gain_value'],
random.random() * self.config['max_gain_value']
))
def generate_new_population(self):
"""
Generate a new population by repeating following steps until the new population is complete
"""
new_population = []
self.fitness_values = []
# find fitness values of the entire population
for chromosomeIndex in range(self.config['population_size']):
self.fitness_values.append(self.run_simulation_for_chromosome(chromosomeIndex))
# generate a new population based on fitness values
for chromosomeIndex in range(self.config['population_size']):
# selection - find two parents of new chromosome
parentIndices = self.algorithm.selection(self.fitness_values)
# crossover - generate a child based on
chromosome = self.algorithm.crossover(self.population[parentIndices[0]], self.population[parentIndices[1]])
# mutation
chromosome = self.algorithm.mutation(chromosome)
new_population.append(chromosome)
self.population = new_population
def run_simulation_for_chromosome(self, chromosomeIndex):
"""
Run simulation for a specific chromosome c.
Returns the fitness function value of the simulation
"""
distance_list = []
current_position = 0
last_distance = 0
current_summation = 0
current_distance = 0
for time in range(self.config['max_timesteps']):
distance_list.append(time)
current_distance = self.map.get(time) - current_position
# note: God integrates empirically
current_summation = current_summation + current_distance
new_velocity = (self.population[chromosomeIndex].kp * current_distance +
self.population[chromosomeIndex].kd * (current_distance-last_distance) +
self.population[chromosomeIndex].ki * current_summation
)
#x = x + dx/dt * dt (dt = 1)
current_position = current_position + new_velocity
distance_list[time] = current_distance
# for the derivative
last_distance = current_distance
return self.algorithm.fitness(distance_list)
def __init__(self, config):
self.config = config
self.map = Map(self.config)
self.algorithm = GeneticAlgorithm(self.config)
self.generate_initial_population()
class Simulation:
def __init__(self, config):
self.config = config
self.map = Map(self.config)
self.algorithm = GeneticAlgorithm(self.config)
self.generate_initial_population()
def generate_initial_population(self):
"""
Generate random population of n chromosomes (suitable solutions for the problem)
Creates a random genome
"""
random.seed()
self.population = []
for chromosome in range(self.config['population_size']):
# create a random chromosome with a random gain value
self.population.append(
Chromosome(random.random() * self.config['max_gain_value'],
random.random() * self.config['max_gain_value'],
random.random() * self.config['max_gain_value']))
def generate_new_population(self):
"""
Generate a new population by repeating following steps until the new population is complete
"""
new_population = []
self.fitness_values = []
# find fitness values of the entire population
for chromosomeIndex in range(self.config['population_size']):
self.fitness_values.append(
self.run_simulation_for_chromosome(chromosomeIndex))
# generate a new population based on fitness values
for chromosomeIndex in range(self.config['population_size']):
# selection - find two parents of new chromosome
parentIndices = self.algorithm.selection(self.fitness_values)
# crossover - generate a child based on
chromosome = self.algorithm.crossover(
self.population[parentIndices[0]],
self.population[parentIndices[1]])
# mutation
chromosome = self.algorithm.mutation(chromosome)
new_population.append(chromosome)
self.population = new_population
def run_simulation_for_chromosome(self, chromosomeIndex):
"""
Run simulation for a specific chromosome c.
Returns the fitness function value of the simulation
"""
distance_list = []
current_position = 0
last_distance = 0
current_summation = 0
current_distance = 0
for time in range(self.config['max_timesteps']):
distance_list.append(time)
current_distance = self.map.get(time) - current_position
# note: God integrates empirically
current_summation = current_summation + current_distance
new_velocity = (
self.population[chromosomeIndex].kp * current_distance +
self.population[chromosomeIndex].kd *
(current_distance - last_distance) +
self.population[chromosomeIndex].ki * current_summation)
#x = x + dx/dt * dt (dt = 1)
current_position = current_position + new_velocity
distance_list[time] = current_distance
# for the derivative
last_distance = current_distance
return self.algorithm.fitness(distance_list)
configuration = build_configuration(args.configFile)
# read a board from the file
board_path = args.boardFile
board = read_board(board_path)
population_size = configuration["population_size"]
evaluation_cls = configuration["evaluation"]
selection_cls = configuration["selection"]
crossover_cls = configuration["crossover"]
mutation_cls = configuration["mutation"]
genetic_algorithm = GeneticAlgorithm(
evaluation=evaluation_cls(),
selection=selection_cls(configuration["number_of_tournaments"], configuration["tournament_size"]),
crossover=crossover_cls(population_size),
mutation=mutation_cls(configuration["mutation_probability"]),
)
# print configuration for the current invocation
rows, cols = board.shape()
board_fill = sum(1 for r in range(rows) for c in range(cols) if board[r, c] != 0)
print(
population_size,
configuration["number_of_tournaments"],
configuration["tournament_size"],
configuration["mutation_probability"],
board_fill,
)
print("Choose your desired algorithm..")
print("1. First Choice Hill Climbing")
print("2. Stochastic Hill Climbing")
print("3. Simulated Annealing")
print("4. Genetic Algorithm")
choice = int(raw_input("your choice :"))
if choice == 1:
os.system("clear")
max_attempt = int(raw_input("Insert max attempt :"))
HillClimbing(request, 1, max_attempt)
elif choice == 2:
os.system("clear")
max_attempt = int(raw_input("Insert max attempt :"))
HillClimbing(request, 2, max_attempt)
elif choice == 3:
os.system("clear")
max_attempt = int(raw_input("Insert max attempt :"))
cooling_rate = float(raw_input("Insert cooling rate :"))
temp = int(raw_input("Insert temperature :"))
SimulatedAnnealing(request, max_attempt, cooling_rate, temp).start()
elif choice == 4:
os.system("clear")
max_attempt = int(raw_input("Insert max attempt :"))
mutation_prob = float(raw_input("Insert mutation probability :"))
max_generation = int(raw_input("Insert maximum number of generation :"))
max_population = int(raw_input("Insert maximum number of population :"))
GeneticAlgorithm(request, mutation_prob, max_attempt, max_generation,
max_population).start()
