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)
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()