def runGA(num_generations): # Inputs of the equation. equation_inputs = [4, -2, 3.5, 5, -11, -4.7] cost_history = [] # Number of the weights we are looking to optimize. num_weights = 3 """ Genetic algorithm parameters: Mating pool size Population size """ sol_per_pop = 8 num_parents_mating = 4 # Defining the population size. pop_size = ( sol_per_pop, num_weights ) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes. #Creating the initial population. new_population = numpy.random.uniform(low=-40.0, high=40.0, size=pop_size) print(new_population) for generation in range(num_generations): print("Generation : ", generation) # Measing the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(equation_inputs, new_population) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) # Generating next generation using crossover. offspring_crossover = ga.crossover( parents, offspring_size=(pop_size[0] - parents.shape[0], num_weights)) # Adding some variations to the offsrping using mutation. offspring_mutation = ga.mutation(offspring_crossover) # Creating the new population based on the parents and offspring. new_population[0:parents.shape[0], :] = parents new_population[parents.shape[0]:, :] = offspring_mutation # The best result in the current iteration. print(new_population[0], new_population[1], new_population[2]) temp1 = test.testga(new_population[0]) temp2 = test.testga(new_population[1]) temp3 = test.testga(new_population[2]) # print(temp1, temp2, temp3) print("Best result : ", numpy.max([temp1, temp2, temp3])) # Getting the best solution after iterating finishing all generations. # At first, the fitness is calculated for each solution in the final generation. fitness = ga.cal_pop_fitness(equation_inputs, new_population) # Then return the index of that solution corresponding to the best fitness. best_match_idx = numpy.where(fitness == numpy.max(fitness)) print("Best solution : ", new_population[best_match_idx, :])
def generation(self, i): # Measuring the fitness fitness = ga.cal_pop_fitness(self.population, self.this_grid, self.blocks) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(self.population, fitness, self.num_parents_mating) # Generating next generation using crossover. offspring_crossover = ga.crossover(parents, self.population, self.num_offspring) # Adding some variations to the offsrping using mutation. mutation_scale = (self.num_generations / ((self.num_generations - i)) + 1) offspring_mutation = ga.mutation(offspring_crossover, mutation_scale=mutation_scale) best_match_idx = np.argmax(fitness) best_fitness = fitness[best_match_idx] print(f'Generation {i} Best result : {max(fitness)}') if self.verbose: print('Average result : ', sum(fitness) / len(fitness)) print('Best idx: ', best_match_idx) print('Best solution : ', self.population[best_match_idx]) print('Best solution fitness : ', best_fitness) very_best = self.population[best_match_idx].squeeze().copy() # Creating the new population based on the parents and offspring. self.population[:parents.shape[0], :] = parents self.population[parents.shape[0]:, :] = offspring_mutation self.best_agents.append(very_best) return max(fitness)
def test_cal_pop_fitness(): pop = numpy.array([[1, 2, 3, 4, 5], [2, 3, 4, 5, 7], [-1, 3, 25, 2, 6], [2, 3, 3, 5, 6], [2, 2, 4, -2, 6]]) equation_inputs = numpy.array([2, 5, 8, 3, 1]) result = numpy.array([53, 73, 225, 64, 46]) assert (cal_pop_fitness(equation_inputs, pop) == result).all()
def ga_pwr(ass_dim, pop, pmat, ngen): sol_per_pop = pop num_parents_mating = pmat # Defining the population size. pop_size = ( sol_per_pop, ass_dim ) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes. #Creating the initial population. new_population = np.random.randint(1, dim, size=pop_size) # print(new_population) num_generations = ngen for generation in range(num_generations): # print("Generation : ", generation) # Measing the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(rl1, new_population) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) # Generating next generation using crossover. offspring_crossover = ga.crossover( parents, offspring_size=(pop_size[0] - parents.shape[0], ass_dim)) # Adding some variations to the offsrping using mutation. offspring_mutation = ga.mutation(offspring_crossover, dim, ass_dim) # Creating the new population based on the parents and offspring. new_population[0:parents.shape[0], :] = parents new_population[parents.shape[0]:, :] = offspring_mutation # The best result in the current iteration. # print("Best result : ", np.max(np.sum(new_population*equation_inputs, axis=1))) # Getting the best solution after iterating finishing all generations. #At first, the fitness is calculated for each solution in the final generation. fitness = ga.cal_pop_fitness(rl1, new_population) # Then return the index of that solution corresponding to the best fitness. best_match_idx = np.where(fitness == np.max(fitness)) res = np.max(fitness) return (res)
print(new_population) """ new_population[0, :] = [2.4, 0.7, 8, -2, 5, 1.1] new_population[1, :] = [-0.4, 2.7, 5, -1, 7, 0.1] new_population[2, :] = [-1, 2, 2, -3, 2, 0.9] new_population[3, :] = [4, 7, 12, 6.1, 1.4, -4] new_population[4, :] = [3.1, 4, 0, 2.4, 4.8, 0] new_population[5, :] = [-2, 3, -7, 6, 3, 3] """ best_outputs = [] num_generations = 100 for generation in range(num_generations): #print("Generation : ", generation) # Measuring the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(equation_inputs, new_population) #print("Fitness") #print(fitness) best_outputs.append( numpy.max(numpy.sum(new_population * equation_inputs, axis=1))) # The best result in the current iteration. #print("Best result : ", numpy.max(numpy.sum(new_population*equation_inputs, axis=1))) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) #print("Parents") #print(parents) # Generating next generation using crossover.
sol_per_pop = 8 num_parents_mating = 4 """ Defining the population size.""" pop_size = (sol_per_pop,num_weights) """Creating the initial population.""" new_population = np.random.uniform(low=-500, high=500, size=pop_size) #print("POPULATION \n" , new_population) """ Performing GA""" best_outputs = [] num_generations = 100 for generation in range(num_generations): print("Generation : ", generation) # Measuring the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(function_inputs, new_population) print("Fitness") print(fitness) best_outputs.append(np.max(np.sum(new_population * function_inputs, axis=1))) # The best result in the current iteration. print("Best result : ", np.max(np.sum(new_population * function_inputs, axis=1))) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) print("Parents") print(parents) # Generating next generation using crossover. offspring_crossover = ga.crossover(parents,
sol_per_pop = 8 # Mating pool size: num_parents_mating = 4 # Defining the population size. pop_size = (sol_per_pop, num_weights) # Creating the weight. weight = numpy.random.uniform(low=-1.0, high=1.0, size=pop_size) print(weight) best_outputs = [] num_generations = 10 for generation in range(num_generations): print("Generation : ", generation) # Measuring the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(equation_inputs, weight) print("Fitness") print(fitness) best_outputs.append(numpy.max(numpy.sum(weight * equation_inputs, axis=1))) # The best result in the current iteration. print("Best result : ", numpy.max(numpy.sum(weight * equation_inputs, axis=1))) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(weight, fitness, num_parents_mating) print("Parents") print(parents) # Generating next generation using crossover. offspring_crossover = ga.crossover(
def run_ga(file_name, sol_per_pop=8, num_parents_mating=4,): """ The y=target is to maximize this equation: y = w1x1+w2x2+w3x3+w4x4+w5x5+6wx6 where (x1,x2,x3,x4,x5,x6)= pizza slices What are the best values for the 6 weights w1 to w6? Weights can only be 0 (absent) and 1(included) We are going to use the genetic algorithm for the best possible values after a number of generations. Genetic algorithm parameters: Mating pool size Population size """ try: f = open("data/" + file_name, "r") if f.mode == 'r': f1 = f.readlines() for row_index in range(0, 2): if row_index == 0: max_val = int(f1[row_index].split(' ')[0]) elif row_index == 1: eq_inputs = [int(val) for val in f1[row_index].split()] except FileNotFoundError: print('Can not find the file') finally: f.close() # Number of the weights we are looking to optimize. num_weights = len(eq_inputs) # Defining the population size. pop_size = (sol_per_pop, num_weights) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes. # Creating the initial population. new_population = numpy.random.randint(low=0, high=2, size=pop_size) if VERBOSE: print(new_population) best_outputs = [] num_generations = 1000 for generation in range(num_generations): if VERBOSE: print("Generation : ", generation) # Measuring the fitness of each chromosome in the population. fitness_val = ga.cal_pop_fitness(eq_inputs, new_population, max_val) if VERBOSE: print("Fitness") print(fitness_val) best_outputs.append(numpy.max(numpy.sum(new_population * eq_inputs, axis=1))) # The best result in the current iteration. if VERBOSE: print("Best result : ", numpy.max(numpy.sum(new_population * eq_inputs, axis=1))) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness_val, num_parents_mating) if VERBOSE: print("Parents") print(parents) # Generating next generation using crossover. offspring_crossover = ga.crossover(parents, offspring_size=(pop_size[0] - parents.shape[0], num_weights)) if VERBOSE: print("Crossover") print(offspring_crossover) # Adding some variations to the offspring using mutation. offspring_mutation = ga.mutation(offspring_crossover, num_mutations=2) if VERBOSE: print("Mutation") print(offspring_mutation) # Creating the new population based on the parents and offspring. new_population[0:parents.shape[0], :] = parents new_population[parents.shape[0]:, :] = offspring_mutation # Getting the best solution after iterating finishing all generations. # At first, the fitness is calculated for each solution in the final generation. fitness_val = ga.cal_pop_fitness(eq_inputs, new_population, max_val) # Then return the index of that solution corresponding to the best fitness. best_match_idx = numpy.where(fitness_val == numpy.max(fitness_val)) best_match_idx = best_match_idx[0][0] if VERBOSE: print("Best solution : ", new_population[best_match_idx, :]) print("Best solution fitness : ", fitness_val[best_match_idx]) print('Max is %s', max_val) print('Pizza Slices are %s ', str(eq_inputs)) return new_population[best_match_idx, :], fitness_val[best_match_idx], max_val, str(eq_inputs) if VIS: matplotlib.pyplot.plot(best_outputs) matplotlib.pyplot.xlabel("Iteration") matplotlib.pyplot.ylabel("Fitness") matplotlib.pyplot.show()
temp = matrix_b[i, 0] matrix_b[i, 0] = matrix_B[i, 0] matrix_B[i, 0] = temp matrix_b = matrix_b * (-1) new_population = numpy.concatenate((matrix_A, matrix_a, matrix_B, matrix_b), axis=1) print(new_population) num_generations = 40 price_previous = None for generation in range(num_generations): print("Generation : ", (generation + 1)) print("Initial generation : \n", (new_population)) # Measing the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(p_naut, new_population, (generation + 1), price_previous) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) print("Selected parents to mate : \n", (parents)) # Generating next generation using crossover. offspring_crossover = ga.crossover( parents, offspring_size=(pop_size[0] - parents.shape[0], num_coeff)) print("After crossover offspring: \n", (offspring_crossover)) # Adding some variations to the offsrping using mutation. offspring_mutation = ga.mutation(offspring_crossover) print("After mutation : \n", (offspring_mutation)) # Creating the new population based on the parents and offspring. new_population[0:parents.shape[0], :] = parents new_population[parents.shape[0]:, :] = offspring_mutation print("New generation : \n", (new_population))
import numpy import ga equation_inputs = [4, -2, 3.5, 5, -11, -4.7] num_wts = 6 #CREATING INITIAL POPULATION sol_per_pop = 8 pop_size = (sol_per_pop, num_wts) #8*6 new_population = numpy.random.uniform(low=-4.0, high=4.0, size=pop_size) #8*6 #STARTING GA num_generations = 50 num_parents_mating = 4 for generation in range(num_generations): print('Generation ::', generation + 1) # 1. Measuring the fitness of each chromosome fitness = ga.cal_pop_fitness(equation_inputs, new_population) #1*8 since we have taken # 8 solution per population i.e 8 chromosomes(solution) so 8 fitness values # are generated # 2. Selecting the best parents in the population for mating parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) #4*6 # since we choose 4 parents and each parents i.e chromosome have 6 genes so 4*6 #-----------MATING---TO----GENERATE----OFFSPRING-------------# # 3. Generating next generation using crossover offspring_size = (pop_size[0] - parents.shape[0], num_wts) #4*6 offspring_crossover = ga.crossover(parents, offspring_size) # 4. Adding some variations to the offsrping using mutation
print(new_Chromosome) """ new_Chromosome[0, :] = [12, 05, 23, 08] new_Chromosome[1, :] = [02, 21, 18, 03] new_Chromosome[2, :] = [10, 04, 13, 14] new_Chromosome[3, :] = [20, 01, 10, 06] new_Chromosome[4, :] = [01, 04, 13, 19] new_Chromosome[5, :] = [20, 05, 17, 01] """ best_outputs = [] num_generations = 1000 for generation in range(num_generations): print("Generation : ", generation) # Measuring the fitness of each chromosome in the Chromosome. fitness = ga.cal_pop_fitness(equation_inputs, new_Chromosome) print("Fitness") print(fitness) best_outputs.append( numpy.max(numpy.sum(new_Chromosome * equation_inputs, axis=1))) # The best result in the current iteration. print("Best result : ", numpy.max(numpy.sum(new_Chromosome * equation_inputs, axis=1))) # Selecting the best parents in theChromosomen for mating. parents = ga.select_mating_pool(new_Chromosome, fitness, num_parents_mating) print("Parents") print(parents)
num_parents_mating = 4 # Number of parents inside the mating pool. num_mutations = 3 # Number of elements to mutate. # Defining the population shape. pop_shape = (sol_per_pop, num_feature_elements) # Creating the initial population. new_population = numpy.random.randint(low=0, high=2, size=pop_shape) print(new_population.shape) best_outputs = [] num_generations = 100 for generation in range(num_generations): print("Generation : ", generation) # Measuring the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(new_population, data_inputs, data_outputs, train_indices, test_indices) best_outputs.append(numpy.max(fitness)) # The best result in the current iteration. print("Best result : ", best_outputs[-1]) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) # Generating next generation using crossover. offspring_crossover = ga.crossover( parents, offspring_size=(pop_shape[0] - parents.shape[0], num_feature_elements)) # Adding some variations to the offspring using mutation.
num_parents_mating = 6 # Defining the population size. pop_size = ( sol_per_pop, ass_dim ) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes. #Creating the initial population. new_population = np.random.randint(1, ass_type_dim, size=pop_size) print(new_population) num_generations = 20 for generation in range(num_generations): print("Generation : ", generation) # Measing the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(rl1, new_population) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) # Generating next generation using crossover. offspring_crossover = ga.crossover( parents, offspring_size=(pop_size[0] - parents.shape[0], ass_dim)) # Adding some variations to the offsrping using mutation. offspring_mutation = ga.mutation(offspring_crossover, ass_type_dim, ass_dim) # Creating the new population based on the parents and offspring. new_population[0:parents.shape[0], :] = parents
print(new_population) new_populationMasq = numpy.random.uniform(low=4.0, high=100.0, size=pop_size) print(new_population) new_populationMed = numpy.random.uniform(low=4.0, high=100.0, size=pop_size) print(new_population) new_populationTest = numpy.random.uniform(low=4.0, high=100.0, size=pop_size) print(new_population) new_populationVeh = numpy.random.uniform(low=4.0, high=100.0, size=pop_size) print(new_population) num_generations = 5 for generation in range(num_generations): print("Generation : ", generation) # Measing the fitness of each chromosome in the population. for each variables or optim axes fitness = ga.cal_pop_fitness(equation_inputs, new_population) #fitnessY1 = ga.cal_pop_fitness(equation_inputs, new_population) fitnessY1 = ga.cal_pop_fitness(equation_inputsLits, new_populationLits) fitnessY2 = ga.cal_pop_fitness(equation_inputsResp, new_populationResp) fitnessY3 = ga.cal_pop_fitness(equation_inputsMasq, new_populationMasq) fitnessY4 = ga.cal_pop_fitness(equation_inputsMed, new_populationMed) fitnessY5 = ga.cal_pop_fitness(equation_inputsTest, new_populationTest) fitnessY6 = ga.cal_pop_fitness(equation_inputsVeh, new_populationVeh) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) parentsY1 = ga.select_mating_pool(new_populationLits, fitnessY1, num_parents_mating) parentsY2 = ga.select_mating_pool(new_populationResp, fitnessY2, num_parents_mating)
new_population = numpy.random.uniform(low=-10.0, high=10.0, size=pop_size) for i in range(11): new_population[0, i] = overfit_wt[i] print("this is the new population when overfit guy is just added", new_population.tolist()) num_generations = 10 for generation in range(num_generations): print("Generation : ", generation) # Measing the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(new_population) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) print("Parents allowed to mate in this generation: ", parents) # Generating next generation using crossover. # offspring_crossover = ga.crossover(parents, # offspring_size=(pop_size[0]-parents.shape[0], num_weights)) offspring_crossover = ga.crossover(parents, offspring_size=(num_children_to_take, num_weights)) print("offsprings crossover length:", len(offspring_crossover))
def calW(qx, qy, num_generations): # Inputs of the equation. equation_inputs = [4, -2, 3.5, 5, -11, -4.7] # Number of the weights we are looking to optimize. num_weights = 6 """ Genetic algorithm parameters: Mating pool size Population size """ sol_per_pop = 8 num_parents_mating = 4 # Defining the population size. pop_size = ( sol_per_pop, num_weights ) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes. #Creating the initial population. new_population = numpy.random.uniform(low=-4.0, high=4.0, size=pop_size) #print(new_population) #my graph for generation in range(num_generations): time.sleep(1) print("Generation : ", generation) # Measing the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(equation_inputs, new_population) # Selecting the best parents in the population for mating. parents = ga.select_mating_pool(new_population, fitness, num_parents_mating) # Generating next generation using crossover. offspring_crossover = ga.crossover( parents, offspring_size=(pop_size[0] - parents.shape[0], num_weights)) # Adding some variations to the offsrping using mutation. offspring_mutation = ga.mutation(offspring_crossover) # Creating the new population based on the parents and offspring. new_population[0:parents.shape[0], :] = parents new_population[parents.shape[0]:, :] = offspring_mutation # The best result in the current iteration. br = numpy.max(numpy.sum(new_population * equation_inputs, axis=1)) ##print("Best result : ",br ) qx.put(generation) qy.put(br) # Getting the best solution after iterating finishing all generations. #At first, the fitness is calculated for each solution in the final generation. fitness = ga.cal_pop_fitness(equation_inputs, new_population) # Then return the index of that solution corresponding to the best fitness. best_match_idx = numpy.where(fitness == numpy.max(fitness)) print("Best solution : ", new_population[best_match_idx, :]) print("Best solution fitness : ", fitness[best_match_idx])
sol_per_pop.append(new_population) for i in range(len(sol_per_pop)): print(sol_per_pop[i]) i = 1 j = 1 print(pop_size) print(sol_per_pop[i][j]) best_outputs = [] num_generations = 100 for generation in range(num_generations): print("Generation : ", generation) # Measuring the fitness of each chromosome in the population. fitness = ga.cal_pop_fitness(sol_per_pop, machine, power) print("Fitness") print(fitness) # Selecting the best parents in the population for mating. bestparents = ga.select_mating_pool(fitness, sol_per_pop) print(bestparents) # Generating next generation using crossover. ga.crossover( sol_per_pop, power, population, machine ) # atualiza a sol_per_pop com os melhores pais e os filhos gerados # Adding some variations to the offspring using mutation. ga.mutation(sol_per_pop, machine)