def ga(df, start, end, _positionList, ranges=[(20,100),(0.01, 1),(0.01, 1),(0.01, 1),(1, 5)], eps=0.01): indv_template = BinaryIndividual(ranges=ranges, eps=eps) population = Population(indv_template=indv_template, size=100) population.init() # Initialize population with individuals. # Use built-in operators here. selection = RouletteWheelSelection() crossover = UniformCrossover(pc=0.8, pe=0.5) mutation = FlipBitMutation(pm=0.3) engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation, analysis=[FitnessStore]) @engine.fitness_register def fitness(indv): n, upper, lower, adds, cutoff = indv.solution df['KAMA'] = talib.KAMA(df.close, int(n)) df['VAR'] = talib.VAR(df.close-df.KAMA.shift(1) - df.close.shift(1)+df.KAMA.shift(2),10) profitsList, buypriceList, sellpriceList, fits,positionList = profitsCal(df, start, end, _positionList, upper=upper, lower=lower, adds = adds, cutoff=cutoff) return float(fits) @engine.analysis_register class ConsoleOutput(OnTheFlyAnalysis): master_only = True interval = 1 def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}'.format(g, engine.fmax) print(best_indv.solution) engine.logger.info(msg) engine.run(ng=30) return population.best_indv(engine.fitness).solution, _positionList
def tain_svm(): indv_template = BinaryIndividual(ranges=[(-8, 8), (-8, 8), (-8, 8)], eps=[0.001, 0.001, 0.001]) population = Population(indv_template=indv_template, size=1000) population.init() # Initialize population with individuals. # In[ ]: selection = RouletteWheelSelection() crossover = UniformCrossover(pc=0.8, pe=0.5) # mutation = FlipBitMutation(pm=0.1) mutation = FlipBitBigMutation(pm=0.1, pbm=0.55, alpha=0.6) engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation, analysis=[ConsoleOutput, FitnessStore]) ############################################################# indv = engine.population.best_indv(engine.fitness).variants c, e, g = indv.variants[1], indv.variants[2], indv.variants[-1] clf = svm.svR(C=c, epsilon=e, gamma=g, kernel='rbf') data_x, data_y = preprocess_pca() clf.fit(data_x, data_y) predictval = clf.predict(data_x) reaval = data_y print(predictval) # In[ ]: engine.run(ng=100)
def test_run(self): ''' Make sure GA engine can run correctly. ''' indv_template = GAIndividual(ranges=[(0, 10)], encoding='binary', eps=0.001) population = GAPopulation(indv_template=indv_template, size=50).init() # Create genetic operators. selection = RouletteWheelSelection() crossover = UniformCrossover(pc=0.8, pe=0.5) mutation = FlipBitMutation(pm=0.1) # Create genetic algorithm engine. engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation) @engine.fitness_register def fitness(indv): x, = indv.variants return x + 10 * sin(5 * x) + 7 * cos(4 * x) engine.run(50)
class pyGaft(Optimizer): def __init__(self, objfunc, var_bounds, individual_size, max_iter, max_or_min, **kwargs): super().__init__(objfunc) self.max_iter = max_iter # 定义个体 / 种群 self.individual = BinaryIndividual(ranges=var_bounds, eps=0.001) self.population = Population(indv_template=self.individual, size=individual_size).init() # Create genetic operators. # selection = RouletteWheelSelection() selection = TournamentSelection() crossover = UniformCrossover(pc=0.8, pe=0.5) mutation = FlipBitBigMutation(pm=0.1, pbm=0.55, alpha=0.6) self.engine = GAEngine(population=self.population, selection=selection, crossover=crossover, mutation=mutation, analysis=[FitnessStore]) @self.engine.fitness_register def fitness(indv): """ 适应度函数: 注意这里默认为优化得到最小值 :param indv: :return: """ x = indv.solution if max_or_min == 'max': return objfunc(x, **kwargs) else: return -objfunc(x, **kwargs) @self.engine.analysis_register class ConsoleOutputAnalysis(OnTheFlyAnalysis): interval = 1 master_only = True def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}'.format( g, engine.fitness(best_indv)) # self.logger.info(msg) def finalize(self, population, engine): best_indv = population.best_indv(engine.fitness) x = best_indv.solution y = engine.fitness(best_indv) msg = 'Optimal solution: ({}, {})'.format(x, y) # self.logger.info(msg) def run(self): self.engine.run(ng=self.max_iter)
def generate(self): best_policy = None best_reward = -float('Inf') candidates = [] eps = 1 # equal to actions space resolution, eps is step size pop_size = 4 cross_prob = 1 exchange_prob = 1 mutation_pob = 1 generation = 4 tmp_reward = [] tmp_policy = [] random.seed(54) turb = 5 try: # Agents should make use of 20 episodes in each training run, if making sequential decisions # Define population indv_template = DecimalIndividual(ranges=[(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1),(0, 1), (0, 1)], eps=eps) population = Population(indv_template=indv_template, size = pop_size) population.init() # Initialize population with individuals. # Create genetic operators # Use built-in operators here. selection = RouletteWheelSelection() crossover = UniformCrossover(pc=cross_prob, pe=exchange_prob) # PE = Gene exchange probability mutation = FlipBitMutation(pm=mutation_pob) # 0.1 todo The probability of mutation # Create genetic algorithm engine to run optimization engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation,) # Define and register fitness function @engine.fitness_register def fitness(indv): p = [0 for _ in range(10)] p = indv.solution policy = {'1': [p[0], p[1]], '2': [p[2], p[3]], '3': [p[4], p[5]], '4': [p[6], p[7]], '5': [p[8], p[9]]}xw reward = self.environment.evaluatePolicy(policy) # Action in Year 1 only print('Sequential Result : ', reward) tmp_reward.append(reward) tmp_policy.append(policy) tmp_single = [] return reward + uniform(-turb, turb) # run engine.run(ng = generation) best_reward = max(tmp_reward) best_policy = tmp_policy[-pop_size] except (KeyboardInterrupt, SystemExit): print(exc_info()) return best_policy, best_reward
def doga(units, ploads, hload, size=50, ng=5, pc=0.8, pe=0.5, pm=0.1): # 计算不同典型日下,最小运行成本均值 def calcost(indv): # 输入改造方案 for chpunit, rtype in zip(chpunits, indv): chpunit.rtype = rtype meancost = 0 # ploads为字典,key:典型日出现的概率,value:[典型日负荷曲线,风电出力极限曲线1,...,风电出力极限曲线n] for p in ploads.keys(): x = ProSimu() x.pload = ploads[p][0] x.hload = hload wn = 0 for wpunit in wpunits: wn += 1 wpunit.maxwp = ploads[p][wn] x.units = units meancost += x.getoptvalue()*p return meancost ranges = list() wpunits = list() chpunits = list() for unit in units: if unit.ptype == 0: # Wind Power Unit wpunits += [unit] elif unit.ptype == 2: # CHP Unit-1 ranges += [(0, 4)] chpunits += [unit] elif unit.ptype == 3: # CHP Unit-2 ranges += [(0, 3)] chpunits += [unit] template = BinaryIndividual(ranges, eps=1) population = Population(indv_template=template, size=size).init() selection = TournamentSelection() crossover = UniformCrossover(pc=pc, pe=pe) mutation = FlipBitMutation(pm=pm) engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation, analysis=[ConsoleOutput, FitnessStore]) @engine.fitness_register @engine.minimize def fitness(indv): # print(type(float(calcost(indv.solution)))) return float(calcost(indv.solution)) engine.run(ng=ng) bestindv = population.best_indv(engine.fitness).solution for unitt, rtype in zip(chpunits, bestindv): unitt.rtype = rtype result = calcost(bestindv) print('Best individual:', bestindv) print('Optimal result:', result)
def tune_weights(self): old_fitness = self.individual.fitness weights_scaling = self.individual.get_subtree_scaling() weights_translation = self.individual.get_subtree_translation() # Create array with range for each scaling and translation parameter range = [ self.scale_range, ] * len(weights_scaling) + [ self.translation_range, ] * len(weights_translation) indv_template = DecimalIndividual(ranges=range, eps=0.1) population = Population(indv_template=indv_template, size=self.pop_size) population.init() engine = GAEngine( population=population, selection=TournamentSelection(), crossover=GaussianCrossover(pc=1.0), mutation=NoMutation(), fitness=self.fitness_function_GAFT, analysis=[ new_early_stopping_analysis(scale_range=self.scale_range) ]) engine.logger = NoLoggingLogger() # Run the GA with the specified number of iterations try: engine.run(ng=self.max_iterations) except ValueError: pass # Get the best individual. best_indv = engine.population.best_indv(engine.fitness) # Log the tuning process print( f"Tuner {np.round(old_fitness, 3)} {np.round(-engine.ori_fmax, 3)}" ) # Only use the new individual if it was really improved if old_fitness > -engine.ori_fmax: weights_scaling, weights_translation = self.split_list( best_indv.solution) self.individual.set_subtree_scaling(weights_scaling) self.individual.set_subtree_translation(weights_translation) self.individual.fitness = -engine.ori_fmax return deepcopy(self.individual)
selection = ExponentialRankingSelection() crossover = UniformCrossover(pc=0.5, pe=0.5) mutation = FlipBitMutation(pm=0.5) engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation) @engine.fitness_register @engine.minimize def fitness(indv): ObjectF = 1 Constraint = 0 for i in indv.solution: ObjectF *= i Constraint += 1 / i**2 return ObjectF + M1(indv.solution) * (Constraint - ( (-b + ma.sqrt(b**2 + 8 * a * epsilon))**2) / (2 * a)) def Generate_noise(sigma): mu_vector = np.zeros([1, n]) covariance = np.diag(sigma) return np.random.multivariate_normal(mu_vector, covariance) if '__main__' == __name__: engine.run(ng=150)
mutation=mutation, analysis=[ConsoleOutput, FitnessStore]) # 加载数据 dataset, labels = load_data('testSet.txt') @engine.fitness_register def fitness(indv): w, b = indv.variants[:-1], indv.variants[-1] min_dis = min([y * (np.dot(w, x) + b) for x, y in zip(dataset, labels)]) return float(min_dis) if '__main__' == __name__: engine.run(300) variants = engine.population.best_indv(engine.fitness).variants w = variants[:-1] b = variants[-1] # 分类数据点 classified_pts = {'+1': [], '-1': []} for point, label in zip(dataset, labels): if label == 1.0: classified_pts['+1'].append(point) else: classified_pts['-1'].append(point) fig = plt.figure() ax = fig.add_subplot(111)
crossover=crossover, mutation=mutation, analysis=[FitnessStore]) # Define fitness function. @engine.fitness_register def fitness(indv): x, = indv.solution return x + 10*sin(5*x) + 7*cos(4*x) # Define on-the-fly analysis. @engine.analysis_register class ConsoleOutputAnalysis(OnTheFlyAnalysis): interval = 1 master_only = True def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}'.format(g, engine.ori_fmax) self.logger.info(msg) def finalize(self, population, engine): best_indv = population.best_indv(engine.fitness) x = best_indv.solution y = engine.ori_fmax msg = 'Optimal solution: ({}, {})'.format(x, y) self.logger.info(msg) if '__main__' == __name__: # Run the GA engine. engine.run(ng=100)
selection=selection, crossover=crossover, mutation=mutation, analysis=[ConsoleOutput, FitnessStore]) # Define fitness function. @engine.fitness_register def fitness(indv): x1, x2 = indv.solution formula = 21.5 + x1 * sin(4 * pi * x1) + x2 * sin(20 * pi * x2) return formula # Best Fitness values are export to best_fit.py engine.run(ng=generation) import matplotlib.pyplot as plt from best_avg_fit import best_avg_fit steps, variants, fits, avgfits = list(zip(*best_avg_fit)) best_step, best_v, best_f, avg_f = steps[-1], variants[-1], fits[-1], avgfits[ -1] fig = plt.figure() ax = fig.add_subplot(111) ax.plot(steps, fits, label="Best_so_far") ax.plot(steps, avgfits, label="Average Fitness") ax.set_xlabel('Generation') ax.set_ylabel('Fitness') ax.legend(loc='lower right')
tmp_policy.append(policy) print('Policy : ', policy) print(policy_450,'**************************good solution***************') #print(policy_bad,'**************************bad solution***************') return reward + uniform(-turb, turb) @engine.analysis_register class ConsoleOutput(OnTheFlyAnalysis): master_only = True interval = 1 def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}'.format(g + 1, engine.fmax) #best_reward = max(tmp_reward[g + pop_size * (generation - 1): g + pop_size * generation]) #print(pop_size * (g - 0), pop_size * (g + 1),'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') REWARDS.append(max(reward_generation[pop_size * (g - 0): pop_size * (g + 1)])) #best_policy = POLICY[tmp_reward.index(best_reward)] #POLICY.append(best_policy) engine.logger.info(msg) engine.run(ng = generation, good_p = good_p, bad_p = bad_p) print(policy_450) x = list(range(len(tmp_reward))) plt.plot(x, tmp_reward) plt.title(f'Sequential Rewards') #plt.savefig(f'./res_geneticAlgorithm/Sequential_Rewards_eps:{eps}_popsize:{pop_size}_generation:{generation}_mutation_pob:{mutation_pob}_exchange_prob:{exchange_prob}_cross_prob:{cross_prob}.jpg') plt.show()
model_labels_ = model_labels.reshape(11, 25, 36, order='A') elif CASE.upper() == 'SEL': model_labels_ = model_labels.reshape(11, 13, 12, order='A') perf_vector = utils.get_projection_errors(true_labels=true_labels, pred_labels=model_labels_) # print("perf = " + str(float(np.mean(perf_vector)))) return float(np.mean(perf_vector)) @engine.analysis_register class ConsoleOutput(OnTheFlyAnalysis): master_only = True interval = 1 def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}, weights: {}'.format( g, engine.fmax, best_indv.decode()) engine.logger.info(msg) if config.VERBOSE: print('\n\n[+] Executing a genetic algorithm with parameters :') print(f'\t\tPop. size : {POPULATION_SIZE}') print(f'\t\tNumber of generations : {NB_GENERATIONS}') print(f'\t\tSelection : Roulette Wheel') print(f'\t\tCrossover probability : {CROSSOVER_PROBABILITY}') print(f'\t\tGenome exchange probability : {GE_PROBABILITY}') print(f'\t\tMutation probability : {MUTATION_PROBABILITY}') engine.run(ng=NB_GENERATIONS)
indv_template = BinaryIndividual(ranges=[XB, YB], eps=EPS) population = Population(indv_template=indv_template, size=POPULATION_SIZE).init() # Create genetic operators. selection = SELECTION crossover = UniformCrossover(pc=PC, pe=PE) mutation = FlipBitBigMutation(pm=PM, pbm=PBM, alpha=ALPHA) # Create genetic algorithm engine. # Here we pass all built-in analysis to engine constructor. engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation, analysis=[ConsoleOutput, FitnessStore]) # Define fitness function. @engine.fitness_register @engine.minimize def fitness(indv): x, y = indv.solution return (1.5 - x + x * y) * (1.5 - x + x * y) + (2.25 - x + x * y * y) * ( 2.25 - x + x * y * y) + (2.625 - x + x * y * y * y) * (2.625 - x + x * y * y * y) engine.run(ng=NG)
def generate(): import random good_seed = int(sys.argv[1]) print('currrrrrrrrrrrrrrrrrrrrrrrrrrrrr', good_seed) envSeqDec = ChallengeProveEnvironment() # Initialise a New Challenge Environment to post entire policy #env = ChallengeEnvironment(experimentCount = 20000) eps = 0.1 # equal to actions space resolution # range/eps pop_size = 4 cross_prob = 0.6 exchange_prob = 0.7 mutation_pob = 0.8 generation = 4 REWARDS = [] NEW = [] POLICY = [] tmp_reward = [] tmp_policy = [] policy_450 = [] reward_generation = [] time = [] random.seed(good_seed) # best_action = ([0], [0.8, 1]) turb = 0 test_action = ([[i/10 for i in range(0, 11)],[i/10 for i in range(0,11)]]) # test_action = ([0, 0.1, 0.2, 0.3, 0.4, 0.5], [0.6, 0.7, 0.8, 0.9, 1]) # 2. Define population indv_template = OrderIndividual(ranges=[(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1)], eps=eps, actions = test_action) # low_bit and high_bit population = Population(indv_template=indv_template, size = pop_size) population.init() # Initialize population with individuals. # 3. Create genetic operators # Use built-in operators here. #selection = RouletteWheelSelection() selection = TournamentSelection() crossover = UniformCrossover(pc=cross_prob, pe=exchange_prob) # PE = Gene exchange probability mutation = FlipBitMutation(pm=mutation_pob) # 0.1 todo The probability of mutation # 4. Create genetic algorithm engine to run optimization engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation,) # analysis=[FitnessStore]) # 5. Define and register fitness function @engine.fitness_register #@engine.dynamic_linear_scaling(target='max', ksi0=2, r=0.9) def fitness(indv): p = [0 for _ in range(10)] p = indv.solution # encode policy = {'1': [p[0], p[1]], '2': [p[2], p[3]], '3': [p[4], p[5]], '4': [p[6], p[7]], '5': [p[8], p[9]]} reward = envSeqDec.evaluatePolicy(policy) # Action in Year 1 only #print('Sequential Result : ', reward) tmp_reward.append(reward) reward_generation.append(reward) tmp_policy.append(policy) #print('Policy : ', policy) #print(policy_450,'**************************good solution***************') #print(policy_bad,'**************************bad solution***************') return reward + uniform(-turb, turb) @engine.analysis_register class ConsoleOutput(OnTheFlyAnalysis): master_only = True interval = 1 def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}'.format(g + 1, engine.fmax) #best_reward = max(tmp_reward[g + pop_size * (generation - 1): g + pop_size * generation]) #print(pop_size * (g - 0), pop_size * (g + 1),'&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') REWARDS.append(max(reward_generation[pop_size * (g - 0): pop_size * (g + 1)])) #best_policy = POLICY[tmp_reward.index(best_reward)] #POLICY.append(best_policy) engine.logger.info(msg) engine.run(ng = generation) # print(policy_450) x = list(range(len(REWARDS))) plt.plot(x, REWARDS) plt.title(f'Sequential Rewards {good_seed}') plt.savefig(f'./GA_trick/GA_seed_{good_seed}.jpg') # #plt.savefig(f'./res_geneticAlgorithm/Sequential_Rewards_eps:{eps}_popsize:{pop_size}_generation:{generation}_mutation_pob:{mutation_pob}_exchange_prob:{exchange_prob}_cross_prob:{cross_prob}.jpg') plt.show()
fitness += (-10 * (time - 1)) else: fitness -= 10000 for key in ovsCheck1: if ovsCheck1[key] > 5: fitness -= 10000 for key in ovsCheck2: if ovsCheck2[key] > 5: fitness -= 10000 print(fitness) return fitness if '__main__' == __name__: sData = schedulesData[2] pData = aircraftsData[2] mEngine.run(ng=10) # variable_ranges = [] # for i in range(0, 97): # variable_ranges.append((0, 30)) # variable_ranges.append((0, 16)) # length = len(variable_ranges) # res = [] # for i in range(0, length): # res.append(1) # sData = schedulesData[2] # pData = aircraftsData[2] # flightRow = sData[i] # planeName = str(flightRow[6]).strip().lower() # i = 0 # for row in pData: # if str(row[0]).strip().lower() == planeName:
engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation, analysis=[ConsoleOutput, FitnessStore]) # 加载数据 dataset, labels = load_data('testSet.txt') @engine.fitness_register def fitness(indv): w, b = indv.variants[: -1], indv.variants[-1] min_dis = min([y*(np.dot(w, x) + b) for x, y in zip(dataset, labels)]) return float(min_dis) if '__main__' == __name__: engine.run(300) variants = engine.population.best_indv(engine.fitness).variants w = variants[: -1] b = variants[-1] # 分类数据点 classified_pts = {'+1': [], '-1': []} for point, label in zip(dataset, labels): if label == 1.0: classified_pts['+1'].append(point) else: classified_pts['-1'].append(point) fig = plt.figure() ax = fig.add_subplot(111)
layer_1 = convert(g_1) layer_2 = convert(g_2) layer_3 = convert(g_3) layer_4 = convert(g_4) layer_5 = convert(g_5) hyper_list = [1, layer_1, layer_2, layer_3, layer_4, layer_5] #TODO: Convert to [1,2,4,8], negative feedback: model size, flops FLOPS = (40.6 + layer_1 * 114.94 / 64.0 + layer_2 * 75.76 / 32.0 + layer_3 * 151.26 / 32.0 + layer_4 * 75.6 / 32 + layer_5 * 150.99 / 32) / 49.4 k = 1.5 print(hyper_list) accuracy = run(hyper_list) fit = accuracy - 0.5 * FLOPS print("Accuracy= ", accuracy, "FLOPS= ", FLOPS, "Fitness= ", fit) return fit def convert(g): layer = 2**g return layer if '__main__' == __name__: # print(indv_template) engine.run(ng=20)
ax.plot(geracoes, n_nines) plt.show() if __name__ == "__main__": individuo = BinaryIndividual(ranges=[(-100, 100), (-100, 100)], eps=0.000001) populacao = Population(indv_template=individuo, size=100) populacao.init() selecao = TournamentSelection() crossover = UniformCrossover(pc=0.65, pe=0.65) mutacao = FlipBitMutation(pm=0.008) engine = GAEngine(population=populacao, selection=selecao, crossover=crossover, mutation=mutacao, analysis=[FitnessStore, ConsoleOutput]) @engine.fitness_register def aptidao(ind): x, y = ind.solution return 0.5 - ((sin(sqrt(x**2 + y**2))**2 - 0.5) / (1 + 0.001 * (x**2 + y**2))**2) engine.run(ng=40) plot_best_fit()
# 定义编码 individual_template = BinaryIndividual(ranges=[(0, 10)], eps=0.001) # 定义种群 _population = Population(indv_template=individual_template, size=20) # 种群初始化 _population.init() # 遗传操作 selection = RouletteWheelSelection() # 个体选择:轮盘赌 crossover = UniformCrossover(pc=0.8, pe=0.5) # 交叉算子:均匀交叉 mutation = FlipBitMutation(pm=0.1) # 变异算子:翻转突变 # 遗传算法引擎 _engine = GAEngine(population=_population, selection=selection, crossover=crossover, mutation=mutation, analysis=[ConsoleOutput]) # 适应度:目标 @_engine.fitness_register # @_engine.minimize def fitness(individual): x, = individual.solution return 0.01 * x + 10 * math.sin(5 * x) + 7 * math.cos(4 * x) if __name__ == '__main__': _engine.run(ng=10)
best_indv = population.best_indv(gen_algo.fitness) msg = 'Generacija: {}, best fitness: {:.3f}'.format(generacija, gen_algo.fmax) gen_algo.logger.info(msg) for generacija in range(individual_template): trenutna_generacija = generacija if mpi.is_master: best_indv = population.best_indv(fitness) else: best_indv = None best_indv = mpi.bcast(best_indv) local_indvs = [] local_size = mpi.split_size(population.size // 2) for _ in range(local_size): roditelji = self.selection.select(population, fitness=fitness) djeca = crossover.cross(*roditelji) dijete= [mtation.mutation(dijete) for dijete in djeca] local_indvs.extend(djeca) indvs = mpi.merge_seq(local_indvs) indvs[0] = best_indv population.individuals = indvs if '__main__' == __name__: gen_algo.run(ng=100):
def generate(self): import random eps = 0.2 # equal to actions space resolution # range/eps pop_size = 2 cross_prob = 0.6 exchange_prob = 0.7 mutation_pob = 0.8 generation = 6 REWARDS = [] tmp_reward = [] tmp_policy = [] bad_p = [] good_p = [] turb = 0 try: # Agents should make use of 20 episodes in each training run, if making sequential decisions first_action = [] for a1 in [i / 10 for i in range(0, 11, 2)]: for a2 in [i / 10 for i in range(0, 11, 2)]: first_action.append([a1, a2]) # [0,0] is absolutely bad action first_action = first_action[1:] action_reward = [] for i in range(len(first_action)): ar = self.environment.evaluateAction(first_action[i]) self.environment.reset() action_reward.append(ar[1]) # get the best policy for first year best_action = first_action[action_reward.index(max(action_reward))] test_action = ([[i / 10 for i in range(0, 11, 2)], [i / 10 for i in range(0, 11, 2)]]) # 2. Define population indv_template = OrderIndividual( ranges=[(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1)], eps=eps, actions=test_action, best_1=best_action) # low_bit and high_bit population = Population(indv_template=indv_template, size=pop_size) population.init() # Initialize population with individuals. # 3. Create genetic operators # Use built-in operators here. selection = LinearRankingSelection() crossover = UniformCrossover( pc=cross_prob, pe=exchange_prob) # PE = Gene exchange probability mutation = FlipBitMutation( pm=mutation_pob) # 0.1 todo The probability of mutation # 4. Create genetic algorithm engine to run optimization engine = GAEngine(population=population, selection=selection, crossover=crossover, mutation=mutation) # 5. Define and register fitness function @engine.fitness_register def fitness(indv): p = [0 for _ in range(10)] p = indv.solution # encode policy = { '1': [p[0], p[1]], '2': [p[2], p[3]], '3': [p[4], p[5]], '4': [p[6], p[7]], '5': [p[8], p[9]] } reward = self.environment.evaluatePolicy(policy) tmp_reward.append(reward) tmp_policy.append(policy) return reward + uniform(-turb, turb) @engine.analysis_register class ConsoleOutput(OnTheFlyAnalysis): master_only = True interval = 1 def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}'.format( g + 1, engine.fmax) REWARDS.append( max(tmp_reward[pop_size * (g - 0):pop_size * (g + 1)])) engine.logger.info(msg) engine.run(ng=generation) best_reward = max(tmp_reward) best_policy = tmp_policy[-pop_size] except (KeyboardInterrupt, SystemExit): print(exc_info()) return best_policy, best_reward
def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) f = engine.fitness(best_indv) msg = 'Generation: {}, best fitness: {}'.format(g, f) self.logger.info(msg) def finalize(self, population, engine): best_indv = population.best_indv(engine.fitness) x = best_indv.variants y = engine.fitness(best_indv) msg = 'Optimal solution: ({}, {})'.format(x, y) self.logger.info(msg) startt=time.time() engine.run(ng=numEpoch) endt=time.time() print('Runing cost time:',(endt-startt)//60,'min',(endt-startt),'s') best_indv = population.best_indv(engine.fitness) x_decode = best_indv.chromsome best_state=decode_sequence(x_decode) best_power=power_by_mtt_fastgraph(best_state,graph) print('best state:',best_state) print('best power:',best_power) write_output(best_state, outputpath, filename)
if '__main__' == __name__: # Open the Hysys Model hyApp = win32.Dispatch("HYSYS.Application") hyApp.Visible = True hySimulationCase = hyApp.ActiveDocument fig = plt.figure(figsize=(16, 9)) ax = fig.add_subplot(111, projection='3d') ax.set_xlabel('THF_PURITY_SPEC') ax.set_ylabel('TOLUENE_PURITY_SPEC') ax.set_zlabel('Profit') #ax.set_title('') #plt.ion() #plt.show() # Run Genetic Algorithm ga_best = engine.run(ng=str_ng) #ax.scatter(ga_best[0][0], ga_best[0][1], ga_best[1], c='r', marker='^', s=160, edgecolor='0.3',alpha=0.2) ax.scatter(ga_best[0][0], ga_best[0][1], ga_best[1], c='r', marker='^', s=160) plt.savefig('C:/ZY/03Output/Profit.png') print(ga_best)
@engine2.minimize def fitness2(indv): x, = indv.solution return func2(x) @engine1.fitness_register @engine1.minimize def fitness1(indv): x, = indv.solution return -func1(x) fitnessFunc1 = fitness1 fitnessFunc2 = fitness2 # Run the engine 1 engine1.run(ng=50) # Run the engine 2 engine2.run(ng=50) # After engine running, we can do something more... # Get the best individual best_indv = engine1.population.best_indv(engine1.fitness) # Get the solution print("========================") print("Function for Alex:") print("========================") print("t = ", best_indv.solution) # And the fitness value print("F(t) = ", fitnessFunc1(best_indv)) best_indv = engine2.population.best_indv(engine2.fitness)
def eval_nn_performance(node_per_layer, num_layer): node_per_layer = int(np.round(node_per_layer)) num_layer = int(np.round(num_layer)) f = open("./depth_cmd.txt", "a") f.write('python run_GA.py %d %d\n' % (node_per_layer, num_layer)) start_time = datetime.now() value = main_fun(num_try=1, width=node_per_layer, depth=num_layer, iter_num=50000, learning_rate=5.0e-4) end_time = datetime.now() m, s = divmod((end_time - start_time).total_seconds(), 60) print( 'node_per_layer = %d, | num_layer = %d | value = %f | time = %dm%ds' % (node_per_layer, num_layer, -float(value), m, s)) return value, (end_time - start_time) # Define fitness function. @engine.fitness_register def fitness(indv): node_per_layer = 10 num_layer = indv.solution value, _ = eval_nn_performance(node_per_layer, num_layer) return -value if __name__ == "__main__": engine.run(ng=4)
class optimize_ga: def __init__(self ,k ,total_implied_variance ,slice_before ,slice_after ,tau): self.k =k self.total_implied_variance =total_implied_variance self.slice_before =slice_before self.slice_after = slice_after self.tau = tau # Define population. indv_template = BinaryIndividual(ranges=[(1e-5, 20),(1e-5, 20),(1e-5, 20)], eps=0.001) self.population = Population(indv_template=indv_template, size=30).init() # Create genetic operators. selection = TournamentSelection() crossover = UniformCrossover(pc=0.8, pe=0.5) mutation = FlipBitMutation(pm=0.1) # Create genetic algorithm engine. self.engine = GAEngine(population=self.population, selection=selection, crossover=crossover, mutation=mutation, analysis=[FitnessStore]) # Define fitness function. @self.engine.fitness_register @self.engine.minimize def fitness(indv): a, b, m, rho, sigma = indv.solution model_total_implied_variance=svi_raw(self.k,np.array([a, b, m, rho, sigma]),self.tau) value = norm(self.total_implied_variance - model_total_implied_variance,ord=2) # if bool(len(self.slice_before)) and np.array(model_total_implied_variance < self.slice_before).any(): # value +=(np.count_nonzero(~np.array(model_total_implied_variance < self.slice_before))*100) # # value = 1e6 # # if bool(len(self.slice_after)) and np.array(model_total_implied_variance > self.slice_after).any(): # value += float(np.count_nonzero(~np.array(model_total_implied_variance > self.slice_after)) * 100) # # value = 1e6 # if np.isnan(value): # value = 1e6 value = float(value) return value # Define on-the-fly analysis. # @self.engine.analysis_register # class ConsoleOutputAnalysis(OnTheFlyAnalysis): # interval = 1 # master_only = True # # def register_step(self, g, population, engine): # best_indv = population.best_indv(engine.fitness) # msg = 'Generation: {}, best fitness: {:.3f}'.format(g, engine.ori_fmax) # self.logger.info(msg) # # def finalize(self, population, engine): # best_indv = population.best_indv(engine.fitness) # x = best_indv.solution # y = engine.ori_fmax # msg = 'Optimal solution: ({}, {})'.format(x, y) # self.logger.info(msg) def optimize(self): self.engine.run(ng=500) return self.population.best_indv(self.engine.fitness).solution
node_per_layer, num_layer = indv.solution value = -eval_NN_performance(node_per_layer, num_layer, data, max_train_iter) return value @engine.analysis_register class ConsoleOutputAnalysis(OnTheFlyAnalysis): interval = 1 master_only = True def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) print('\033[0;31mGeneration: {}\033[0m'.format(g+1)) print('-' * 100) def finalize(self, population, engine): best_indv = population.best_indv(engine.fitness) x = best_indv.solution y = engine.ori_fmax print('\033[0;31Optimal solution: (node_per_layer:{}, num_layer:{}, value:{})\033[0m'.format(x[0], x[1], y)) if '__main__' == __name__: start = datetime.now() engine.run(ng=5) end = datetime.now() h, temp = divmod((end - start).total_seconds(), 3600) m, s = divmod(temp, 60) print('\033[0;31mTotal Time: %dh%dm%ds\033[0m' % (h, m, s))
def register_step(self, g, population, engine): best_indv = population.best_indv(engine.fitness) msg = 'Generation: {}, best fitness: {:.3f}'.format(g, engine.ori_fmax) self.logger.info(msg) def finalize(self, population, engine): best_indv = population.best_indv(engine.fitness) x = best_indv.solution y = engine.ori_fmax msg = 'Optimal solution: ({}, {})'.format(x, y) self.logger.info(msg) if '__main__' == __name__: # Run the GA engine and print every generation engine.run(ng=500) best_indv = engine.population.best_indv(engine.fitness) print('Max({0},{1})'.format(best_indv.solution[0], engine.fitness(best_indv))) x = np.linspace(0, 15, 10000) y = [-3 * (i - 30)**2 * math.sin(i) for i in x] plt.plot(x, y) plt.xlabel('x') plt.ylabel('y') plt.title('function') plt.axis([-1, 16, -3000, 3000]) plt.scatter(best_indv.solution[0], engine.fitness(best_indv), color='r') a = round(best_indv.solution[0], 4) b = round(engine.fitness(best_indv), 4) plt.annotate('Max(' + str(a) + ',' + str(b) + ')', xy=(best_indv.solution[0], engine.fitness(best_indv)),