def cal_opt(numParm, fintness, funcname, func, stock_data, stockName): datarange = [[1, 20], [6, 50], [20, 100]] datarange = datarange[:numParm] genome = G1DList.G1DList(numParm) genome.evaluator.set(func(fintness, funcname, stock_data, stockName)) # genome.setParams(allele=Grid_Constructor(numline,data1)) genome.setParams(allele=Grid_Constructor(1, numParm, datarange)) genome.initializator.set(Initializators.G1DListInitializatorAllele) genome.mutator.set(Mutators.G1DListMutatorAllele) ga = GSimpleGA.GSimpleGA(genome, seed=400) ga.setPopulationSize(80) ga.setGenerations(150) ga.setCrossoverRate(0.8) ga.setMutationRate(0.2) ga.selector.set(Selectors.GRankSelector) # ga.terminationCriteria.set(GSimpleGA.FitnessStatsCriteria) # Change the scaling method pop = ga.getPopulation() pop.scaleMethod.set(Scaling.SigmaTruncScaling) ga.evolve(freq_stats=10) best = ga.bestIndividual() return [best.genomeList, best.score]
def main_run(): genome = G1DList.G1DList(42) genome.evaluator.set( lambda chromosome: evaluate(chromosome.getInternalList())) genome.crossover.set(Crossovers.G1DListCrossoverEdge) genome.initializator.set(Initializators.G1DBinaryStringInitializator) ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(500) ga.setMinimax(Consts.minimaxType["maximize"]) ga.setCrossoverRate(0.6) ga.setMutationRate(0.01) ga.setPopulationSize(15) try: ga.evolve(freq_stats=1000) except: print("\n") best = ga.bestIndividual() ch = best.genomeList evaluate(ch)
def run_main(): # Genome instance genome = G1DList.G1DList(40) # The gauss_mu and gauss_sigma is used to the Gaussian Mutator, but # if you don't specify, the mutator will use the defaults genome.setParams(rangemin=0, rangemax=10, gauss_mu=4, gauss_sigma=6) genome.mutator.set(Mutators.G1DListMutatorIntegerGaussian) # The evaluator function (objective function) genome.evaluator.set(eval_func) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) #ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(800) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=150) # Best individual print ga.bestIndividual()
def run(self): # Allele define valid chromosome value alleles = GAllele.GAlleles() # Define gene with 2 chromosomes # MA type alleles.add(GAllele.GAlleleList([0, 1, 2, 3, 4])) # MA range alleles.add(GAllele.GAlleleRange(1, 99)) # Genome instance, 1D List genome = G1DList.G1DList(len(alleles)) # Sets the range max and min of the 1D List genome.setParams(allele=alleles) # The evaluator function (evaluation function) genome.evaluator.set(self.fitness) # This mutator and initializator will take care of # initializing valid individuals based on the allele set # that we have defined before genome.mutator.set(Mutators.G1DListMutatorAllele) genome.initializator.set(Initializators.G1DListInitializatorAllele) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) # Set the Roulette Wheel selector method, the number of generations and # the termination criteria ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(self.gen) ga.setPopulationSize(self.pop) ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) pop = ga.getPopulation() pop.scaleMethod.set(Scaling.SigmaTruncScaling) ga.evolve(freq_stats=10) # Best individual self.best = ga.bestIndividual()
def main(f_phi, f_psi): phi = numpy.loadtxt(f_phi) psi = numpy.loadtxt(f_psi) l_phi = (phi <= -30.) * (phi > -100.) * 1 l_psi = (psi <= -7.) * (psi >= -67.) * 1 h_matrix = l_phi * l_psi logical_mat = tovw(h_matrix) number_conf = len(logical_mat) number_helical_w = ((logical_mat > 0) * 1).sum() number_helical_v = ((logical_mat < 0) * 1).sum() n_res = len(logical_mat[0]) partition_f = make_partition(len(logical_mat[0]), v=1, w=1) print logical_mat print number_conf, number_helical_w, number_helical_v, partition_f eval_func = scoring_function_factory(number_conf, number_helical_w, number_helical_v, n_res) genome = G1DList.G1DList(2) genome.evaluator.set(eval_func) genome.setParams(rangemin=0.000001, rangemax=1.0, gauss_sigma=0.01) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealGaussian) ga = GSimpleGA.GSimpleGA(genome) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setElitism(True) #ga.selector.set(Selectors.GRouletteWheel) ga.selector.set(Selectors.GRankSelector) ga.nGenerations = n_steps ga.setMutationRate(0.20) ga.evolve(freq_stats=10) print ga.bestIndividual()
def run_main(): # Genome instance genome = G1DList(20) genome.setParams(rangemin=-6.0, rangemax=6.0) # Change the initializator to Real values genome.initializator.set(G1DListInitializatorReal) # Change the mutator to Gaussian Mutator genome.mutator.set(G1DListMutatorRealGaussian) # The evaluator function (objective function) genome.evaluator.set(eval_func) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(100) # Do the evolution ga.evolve(freq_stats=10) # Best individual print(ga.bestIndividual())
def evolve(): genome = G1DList.G1DList(TOTAL) genome.setParams(rangemin=0, rangemax=TOTAL - 1) genome.evaluator.set(eval_func) ga = GSimpleGA.GSimpleGA(genome) ga.selector.set(Selectors.GRouletteWheel) ga.setMutationRate(0.6) ga.setGenerations(100) ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) ga.evolve(freq_stats=20) ''' pop = ga.getPopulation() bf = pop.bestFitness() print bf br = pop.bestRaw() print br for ind in pop: print ind.fitness ''' best = ga.bestIndividual() print best pop = ga.getPopulation() print pop for c in best.genomeList: result.append(A[c]) print result
def save_best_average_worst(ga_engine=GSimpleGA.GSimpleGA(G1DList.G1DList()), temp_fname='.__current_best_average_worst__.csv'): pop, fitnesses = get_population(ga_engine) optimization_type = ga_engine.getMinimax() high_ind = pop[np.argmax(fitnesses)] low_ind = pop[np.argmin(fitnesses)] average = np.mean(pop, axis=0) if optimization_type == Consts.minimaxType['maximize']: best = np.copy(high_ind) worst = np.copy(low_ind) elif optimization_type == Consts.minimaxType['minimize']: best = np.copy(low_ind) worst = np.copy(high_ind) df = pd.DataFrame() df['best'] = best df['average'] = average df['worst'] = worst fname = os.path.join(ga_folder(), temp_fname) df.to_csv(fname, index=False) return False
def run_main(): print "Starting the experiment." print "Raw score is calculated as 100000 - predicted_score" print "Because the pyevolve can only maximize the fitness function" genome = G1DList.G1DList(15) genome.setParams(rangemin=0, rangemax=119) genome.mutator.set(Mutators.G1DListMutatorSwap) genome.mutator.add(Mutators.G1DListMutatorIntegerRange) genome.crossover.set(Crossovers.G1DListCrossoverUniform) genome.evaluator.set(eval_func) ga = GSimpleGA.GSimpleGA(genome) ga.setPopulationSize(900) ga.selector.set(Selectors.GTournamentSelector) ga.setGenerations(100) ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) sqlite_adapter = DBAdapters.DBSQLite(identify="ex1", resetDB=True) ga.setDBAdapter(sqlite_adapter) ga.evolve(freq_stats=1) print "Best ga: " print ga.bestIndividual()
def main_run(): genome = GTree.GTreeGP() root = GTree.GTreeNodeGP('a', Consts.nodeType["TERMINAL"]) genome.setRoot(root) genome.setParams(max_depth=2, method="ramped") genome.evaluator += eval_func genome.mutator.set(Mutators.GTreeGPMutatorSubtree) ga = GSimpleGA.GSimpleGA(genome) ga.setParams(gp_terminals=['a', 'b'], gp_function_prefix="gp") ga.setMinimax(Consts.minimaxType["maximize"]) ga.setGenerations(500) ga.setCrossoverRate(1.0) ga.setMutationRate(0.08) ga.setPopulationSize(80) ga(freq_stats=1) print ga.bestIndividual() graph = pydot.Dot() ga.bestIndividual().writeDotGraph(graph) graph.write_jpeg('tree.png', prog='dot')
def synthesizeByGA(positives, negatives): """Finds an NFA consistent with the input by means of GA Input: a sample, S = (positives, negatives) Output: an NFA or None""" global negPart, PTA negPart = negatives PTA = buildPTA(positives).toNFA() genome = G1DList.G1DList(len(PTA.States)) genome.setParams(rangemin=0, rangemax=len(PTA.States) - 1) genome.evaluator.set(eval_func) ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(500) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(0.9) ga.setMutationRate(0.05) ga.setPopulationSize(200) ga.evolve() best_indiv = ga.bestIndividual() if best_indiv.getRawScore() == float('infinity'): return None else: Pi = decodeToPi(best_indiv) A = inducedNFA(Pi, PTA) return A
def run_main(): # Genome instance, 1D List of 50 elements genome = G1DList.G1DList(50) # Sets the range max and min of the 1D List genome.setParams(rangemin=0, rangemax=10) # The evaluator function (evaluation function) genome.evaluator.set(eval_func) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) # Set the Roulette Wheel selector method, the number of generations and # the termination criteria ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(500) ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) # Sets the DB Adapter, the resetDB flag will make the Adapter recreate # the database and erase all data every run, you should use this flag # just in the first time, after the pyevolve.db was created, you can # omit it. sqlite_adapter = DBAdapters.DBSQLite(identify="ex1", resetDB=True) ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 20 generations best_individual = ga.evolve(freq_stats=20) # Best individual print(best_individual) # Another way to find best individual print(ga.bestIndividual())
def run_main(num_weights, ga_min=ga_min, ga_max=ga_max, Stat=Stats, freq=freq_stat, gen=gen, mutp=mutp, popsize=popsize, cc=cc, fitness=fitness, initializator=initializator, mutator=mutator, crossover=crossover, scaling=scaling, selector=selector, termination=termination): # Genome instance genome = G1DList.G1DList(num_weights) # print 'genome', genome genome.setParams(rangemin=ga_min, rangemax=ga_max, bestrawscore=0.0000, rounddecimal=4) genome.initializator.set(initializator) genome.mutator.set(mutator) # genome.crossover.set(crossover) # genome.mutator.set(Mutators.G1DListMutatorSwap) # The evaluator function (objective function) if fitness == 'rmse': genome.evaluator.set(cal_pop_fitness_rmse) elif fitness == 'chi2red': genome.evaluator.set(cal_pop_fitness_chi2red) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) # ga.setMultiProcessing(flag=False, full_copy=False) pop = ga.getPopulation() # pop.scaleMethod.set(Scaling.SigmaTruncScaling) pop.scaleMethod.set(scaling) ga.selector.set(selector) # ga.selector.set(Selectors.GRouletteWheel) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setGenerations(gen) ga.setMutationRate(mutp) ga.setPopulationSize(popsize) ga.terminationCriteria.set(termination) # ga.setCrossoverRate(0.95) # ga.stepCallback.set(evolve_callback) # ga.terminationCriteria.set(GSimpleGA.FitnessStatsCriteria) # ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) # ga.setInteractiveGeneration(2) # Sets the DB Adapter, the resetDB flag will make the Adapter recreate # the database and erase all data every run, you should use this flag # just in the first time, after the pyevolve.db was created, you can # omit it. # sqlite_adapter = DBAdapters.DBSQLite(identify="eniigma_"+str(cc), resetDB=True) # ga.setDBAdapter(sqlite_adapter) if os.path.exists(home1 + 'pyevolve.db') == False: sqlite_adapter = DBAdapters.DBSQLite(identify="eniigma_" + str(cc), resetDB=True) ga.setDBAdapter(sqlite_adapter) else: sqlite_adapter = DBAdapters.DBSQLite(identify="eniigma_" + str(cc), resetDB=False) ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 10 generations if Stat == 'True': ga.evolve(freq_stats=freq) else: ga.evolve(freq_stats=0) # for i in xrange(len(pop)): # print(pop[i].fitness) # Best individual best = ga.bestIndividual() # print 'Best weights (genes) in the last combination', best numpy.savetxt(home1 + 'Best_values.txt', best) # print "Best individual score in the last combination: %.2e" % best.getRawScore() numpy.savetxt(home1 + 'Best_score.txt', [best.getRawScore()], fmt='%1.4e') f = open('comb_score.txt', 'a') f.write('{0:f} {1:f}\n'.format(best.getRawScore(), cc)) f.close() f2 = open('comb_score0.txt', 'w') f2.write('{0:f} {1:f}\n'.format(best.getRawScore(), cc)) f2.close()
def run_ga(): global ga #___________________Genome instance # setOfAlleles = GAllele.GAlleleList() pars_min = velocity_min + depth_min + vpvs_min pars_max = velocity_max + depth_max + vpvs_max num_pars = len(pars_min) for (vmin, vmax) in zip(pars_min, pars_max): tmp = GAllele.GAlleleRange(vmin, vmax, real=True) setOfAlleles.add(tmp) genome = G1DList.G1DList(num_pars) genome.setParams(allele=setOfAlleles) genome.initializator.set(Initializators.G1DListInitializatorAllele) genome.mutator.set(Mutators.G1DListMutatorAllele) genome.crossover.set(Crossovers.G1DListCrossoverUniform) #___________________The evaluator function (objective function) # genome.evaluator.set(eval_func) #___________________Genetic Algorithm Instance # ga = GSimpleGA.GSimpleGA(genome, seed=int(seed)) if num_cpu: ga.setMultiProcessing(True, True, int(num_cpu)) if ga_selector == 'T': ga.selector.set(Selectors.GTournamentSelector) if ga_selector == 'R': ga.selector.set(Selectors.GRouletteWheel) if ga_selector == 'N': ga.selector.set(Selectors.GRankSelector) if ga_selector == 'M': ga.selector.setRandomApply(True) ga.selector.set(Selectors.GTournamentSelector, 0.75) ga.selector.add(Selectors.GRouletteWheel, 0.20) ga.selector.add(Selectors.GRankSelector) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setGenerations(int(generationSize)) ga.setPopulationSize(int(populationSize)) ga.setCrossoverRate(pCrossover) ga.setMutationRate(pMutation) ga.setElitism(True) ga.setElitismReplacement(int(num_etlsm)) #___________________Sets the DB Adapter # sqlite_adapter = DBAdapters.DBSQLite(identify=dbase_name, resetDB=eval(resetDB)) ga.setDBAdapter(sqlite_adapter) #___________________Do the evolution # ga.evolve(freq_stats=5) #___________________Print Best individual # best = ga.bestIndividual() best_rs = best.getRawScore() best_v = best.genomeList[:len(velocity_min)] best_d = best.genomeList[len(velocity_min):2 * len(velocity_min)] best_r = best.genomeList[2 * len(velocity_min):] print '' print '+++ Best Raw Score =', best_rs print '+++ FinalModel :' print ' +++ Velocity :', rnd(best_v, 2) print ' +++ Depth :', rnd(best_d, 2) print ' +++ VpVs :', rnd(best_r, 2) return best, best_rs, best_v, best_d, best_r
def evolve(hackers, hosts, initial_matching, num_gens, stat_freq, population_size, mutation_rate, crossover_rate, elitism, selector): num_hackers = len(hackers) (assignments, m_gp_assigned_hackers, f_gp_assigned_hackers, np_assigned_hackers) = initial_matching # 1. Add Fake Hackers to represent unused spaces. for host in hosts: fakes_needed = host.capacity - host.fill for i in range(fakes_needed): fake_hacker = FHacker() assignments.append((fake_hacker, host)) hackers.append(fake_hacker) # 2. Sort the assignments by their hacker id, same order as the hackers list assignments = sorted(assignments, key=lambda pair: pair[0].id) hackers = sorted(hackers, key=lambda hacker: hacker.id) hosts = sorted(hosts, key=lambda host: host.id) def eval_func(matching, dev=0): score = 0.0 host_to_hack = {} team_to_hosts = {} for e in range(len(matching)): # dictionary of hosts to lists of hackers who they are hosting if hosts[matching[e]] not in host_to_hack: host_to_hack[hosts[matching[e]]] = [] # TODO(Ben): Add fakeness if not hackers[e].is_fake: host_to_hack[hosts[matching[e]]].append(hackers[e]) # dictionary of teams to who is hosting its members if hackers[e].team not in team_to_hosts: team_to_hosts[hackers[e].team] = [] team_to_hosts[hackers[e].team].append(hosts[matching[e]]) total_cap_var = calc_fullness_var(host_to_hack) score_cap_var = -25 * (tanh(0.05 * total_cap_var) - 1) total_team_split = calc_team_division(team_to_hosts, dev=dev) score_team_split = -25 * (tanh(0.05 * total_team_split - 2) - 1) total_gender_mismatches = calc_gender_mismatch(host_to_hack) score_gender_mismatches = -13 * \ (tanh(0.1 * (total_gender_mismatches - 15)) - 1) total_sleeptime_diff = calc_sleeptime_diff(host_to_hack) score_sleeptime = -25 * (tanh(0.0025 * total_sleeptime_diff) - 1) score = score_cap_var + score_team_split + \ score_gender_mismatches + score_sleeptime # Diagnostic tools if dev > 0: print("Capacity variance: " + str(total_cap_var)) print(" Team splits: " + str(total_team_split)) print("Gender mismatches: " + str(total_gender_mismatches)) print(" Sleeptime diff: " + str(total_sleeptime_diff)) print("") print(" SCORE BREAKDOWN ") print("Capacity var: " + str(score_cap_var)) print(" Team splits: " + str(score_team_split)) print("Gender prefs: " + str(score_gender_mismatches)) print(" Sleep var: " + str(score_sleeptime)) print("-----------------------------") # 80 is max possible score print("Total Score " + str(score) + "/80") return score def init_genome(genome, **args): # Initialise hacker_assignments to the outcome of the greedy algorithm genome.genomeList = [hosts.index(host) for _, host in assignments] def mutate_genome(genome, **args): """ Mutations that respect gender preference, by mutating only within gender/gender preference groups. """ global m_gp_assigned_hackers global f_gp_assigned_hackers global np_assigned_hackers def indices_of_subset(subset): return [i for i, x in enumerate(genome) if hackers[x] in subset] def mutate_subset(subset): mutations = 0 for idx in xrange(len(subset)): if Util.randomFlipCoin(args["pmut"]): Util.listSwapElement( genome, subset[idx], subset[rand_randint(0, len(subset) - 1)]) mutations += 1 return mutations if args["pmut"] <= 0.0: return 0 listSize = len(genome) mutations = args["pmut"] * listSize # 1. Find subsets to do mutations in. m_gp = indices_of_subset(m_gp_assigned_hackers) f_gp = indices_of_subset(f_gp_assigned_hackers) np_ = indices_of_subset(np_assigned_hackers) # 2. Run random mutations on each subset. if mutations < 1.0: mutations = mutate_subset(m_gp) + mutate_subset( f_gp) + mutate_subset(np_) else: for _ in xrange(int(round(mutations))): a = [m_gp, f_gp, np_] len_a = np.array(map(len, a)) subset = choice(a, p=(len_a / norm(len_a, ord=1))) Util.listSwapElement(genome, randint(0, len(subset) - 1), randint(0, len(subset) - 1)) return int(mutations) # Hacker assignment is the mapping between hacker index and host index hacker_assignments = G1DList.G1DList(num_hackers) hacker_assignments.evaluator.set(eval_func) hacker_assignments.mutator.set(mutate_genome) hacker_assignments.crossover.set(Crossovers.G1DListCrossoverCutCrossfill) hacker_assignments.initializator.set(init_genome) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(hacker_assignments) ga.setDBAdapter(DBFileCSV(identify="stage_2", frequency=10, reset=True)) ga.selector.set(selector) ga.setGenerations(num_gens) ga.setCrossoverRate(crossover_rate) ga.setPopulationSize(population_size) ga.setMutationRate(mutation_rate) ga.setElitismReplacement(elitism) # Do the evolution, with stats dump ga.evolve(freq_stats=stat_freq) best = ga.bestIndividual() best_assignments = [(hackers[i], hosts[best[i]]) for i in range(len(best))] eval_func(best, dev=1) ga.printStats() return best, best_assignments
def ga_layout(dim, objfunc, initfunc, statsfile, coordx, coordy, coordz, **kwargs): """ Run Genetic Algorithm Runs the Genetic Algorithm using the Pyevolve module, an implementation of the Simple GA is used to minimize the objective function. :param dim, dimension of the problem (number of nodes of the network) :param objfunc, objective function object :param initfunc, initialize function object :param statsfile, the file name of a CSV tect file to save the results :param coordx, list with x-axis coordinates :param coordy, list with y-axis coordinates :param run, the number of the current execution :param gen, generations of the GA :param pop, population size of the GA :param cross, crossover rate of the GA :param mut, mutation rate of the GA :return best, a list of the diameters with the maximum fitness """ # Get the arguments run = kwargs.get('run', 0) gen = kwargs.get('gen', 100) pop = kwargs.get('pop', 80) xover = kwargs.get('xover', 0.9) mut = kwargs.get('mut', 0.02) # Genome instance genome = G1DList.G1DList(dim) genome.initializator.set(lambda x, **args: initfunc(x, dim)) # The evaluator function (objective function) genome.evaluator.set(lambda x, **args: objfunc(x, coordx, coordy, coordz)) genome.mutator.set(Mutators.G1DListMutatorSwap) genome.crossover.set(Crossovers.G1DListCrossoverTwoPoint) # Genetic Algorithm instance ga = GSimpleGA.GSimpleGA(genome) ga.setMinimax(Consts.minimaxType["minimize"]) # Use roulette wheel with linear scaling p = ga.getPopulation() p.scaleMethod.set(Scaling.LinearScaling) ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(gen) ga.setPopulationSize(pop) ga.setCrossoverRate(xover) ga.setMutationRate(mut) # Save stats to CSV file for later analysis csv_adapter = DBAdapters.DBFileCSV(identify="run" + str(run), filename=statsfile, reset=False) ga.setDBAdapter(csv_adapter) # Do the evolution, with stats dump # frequency of certain generations ga.evolve(freq_stats=100) stats = ga.getStatistics() print(stats) best = ga.bestIndividual() return best
def run_sim(astr, max_del=5): """ given an example deletion/retention string, where "_" is a deletion, run a ga simulation to determine the deletion lengths likely to have created that pattern of deletion-lengths """ # hack to let pygene do it's minimization. BIGNUMBER = 1e8 num_deletions = astr.count('_') region_length = len(astr) real_runs = count_deletion_runs(astr) max_real_run_len = real_runs[-1][0] def evaluator(chromosome): deletion_lengths = list(chromosome) # since gen_deletions is random, do multiple tries to # make sure an outlier doesnt screw it up. ntries = 10 observed_counts = dict(real_runs) observed_counts = np.array( [observed_counts.get(i, 0) for i in range(1, max_real_run_len)], 'f') ll = 0 for tries in range(ntries): sim_str, sim_runs = gen_deletions( region_length, deletion_lengths=deletion_lengths, num_deletions=num_deletions, count_retentions=False) sim_runs = dict(sim_runs) # fill in zeros. add 1 to avoid probs with log. sim_runs = np.array( [sim_runs.get(i, 0) for i in range(1, max_real_run_len)], 'f') + 1 sim_freqs = sim_runs / sim_runs.sum() ll += np.sum(observed_counts * np.log(sim_freqs)) return BIGNUMBER + ll genome = G1DList.G1DList(len(astr)) # deletion lenghts vary between 1 and 5 (max_del) genome.setParams(rangemin=1, rangemax=max_del, roundDecimal=1) genome.initializator.set(initializator) genome.mutator.set(mutator) genome.evaluator.set(evaluator) ga = GSimpleGA.GSimpleGA(genome) ga.setMinimax(minimaxType['maximize']) ga.setGenerations(GA_GENERATIONS) ga.evolve(freq_stats=0) best = ga.bestIndividual() return { 'deletion_lengths': sorted(list(best)), 'fitness': best.fitness, 'score': best.score }
def evolve(hackers, hosts, num_gens, stat_freq, population_size, mutation_rate, crossover_rate, elitism, selector): def init_genome(genome, **args): # Initialise hacker_assignments to the outcome of the greedy algorithm genome.genomeList = range(0, len(hackers)) def eval_func(genome, dev=0): # 1. Generate the matching. matching = greedy_match_for_genome(genome, hackers, hosts)[0] # 2. Preprocess for scoring. host_to_hack = {} team_to_hosts = {} for hacker, host in matching: # dictionary of hosts to lists of hackers who they are hosting if host not in host_to_hack: host_to_hack[host] = [] host_to_hack[host].append(hacker) # dictionary of teams to who is hosting its members if hacker.team not in team_to_hosts: team_to_hosts[hacker.team] = [] team_to_hosts[hacker.team].append(host) # 3. Do the scoring. total_cap_var = calc_fullness_var(host_to_hack) score_cap_var = -25 * (tanh(0.05 * total_cap_var) - 1) total_team_split = calc_team_division(team_to_hosts, dev=dev) score_team_split = -25 * (tanh(0.05 * total_team_split - 2) - 1) total_gender_mismatches = calc_gender_mismatch(host_to_hack) score_gender_mismatches = -13 * \ (tanh(0.1 * (total_gender_mismatches - 15)) - 1) total_sleeptime_diff = calc_sleeptime_diff(host_to_hack) score_sleeptime = -25 * (tanh(0.0025 * total_sleeptime_diff) - 1) score = score_cap_var + score_team_split + \ score_gender_mismatches + score_sleeptime # Diagnostic tools if dev > 0: print("Capacity variance: " + str(total_cap_var)) print(" Team splits: " + str(total_team_split)) print("Gender mismatches: " + str(total_gender_mismatches)) print(" Sleeptime diff: " + str(total_sleeptime_diff)) print("") print(" SCORE BREAKDOWN ") print("Capacity var: " + str(score_cap_var)) print(" Team splits: " + str(score_team_split)) print("Gender prefs: " + str(score_gender_mismatches)) print(" Sleep var: " + str(score_sleeptime)) print("-----------------------------") # 80 is max possible score print("Total Score " + str(score) + "/80") return score # Hacker assignment is the mapping between hacker index and host index hacker_order = G1DList.G1DList(len(hackers)) hacker_order.evaluator.set(eval_func) hacker_order.crossover.set(Crossovers.G1DListCrossoverCutCrossfill) hacker_order.mutator.set(Mutators.G1DListMutatorSwap) hacker_order.initializator.set(init_genome) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(hacker_order) ga.setDBAdapter(DBFileCSV(identify="stage_1", frequency=10, reset=True)) ga.selector.set(selector) ga.setGenerations(num_gens) ga.setCrossoverRate(crossover_rate) ga.setPopulationSize(population_size) ga.setMutationRate(mutation_rate) ga.setElitismReplacement(elitism) # Do the evolution, with stats dump ga.evolve(freq_stats=stat_freq) # Print outcome. best = ga.bestIndividual() eval_func(best, dev=1) ga.printStats() return best
# iterate over the chromosome for value in chromosome: if value == 0: score += 0.5 return score # Genome instance genome = G1DList.G1DList(100) genome.setParams(rangemin=0, rangemax=10) # The evaluator function (objective function) genome.evaluator.set(eval_func) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome, 666) ga.setGenerations(80) ga.setMutationRate(0.2) # Create DB Adapter and set as adapter #sqlite_adapter = DBAdapters.DBSQLite(identify="ex6", resetDB=True) # noqa #ga.setDBAdapter(sqlite_adapter) # noqa # Using CSV Adapter #csvfile_adapter = DBAdapters.DBFileCSV() # noqa #ga.setDBAdapter(csvfile_adapter) # noqa # Using the URL Post Adapter # urlpost_adapter = DBAdapters.DBURLPost(url="http://whatismyip.oceanus.ro/server_variables.php", post=False) # ga.setDBAdapter(urlpost_adapter)
def Genetic(): genome = G1DList.G1DList(20) genome.evaluator.set(eval_func) ga = GSimpleGA.GSimpleGA(genome) ga.evolve(freq_stats=10) print ga.bestIndividual()
def run(self): """ run the Genetic Training""" genome = G2DList.G2DList(*self.shapeParamList) genome.setParams(rangemin=0, rangemax=1, gauss_mu=0, gauss_sigma=self.mutationSigma) genome.evaluator.set(self.evaluateParam) genome.initializator.set(Initializators.G2DListInitializatorReal) genome.mutator.set(Mutators.G2DListMutatorRealGaussian) if self.crossover == "uniform": # Uniform means not regarding the location genome.crossover.set(Crossovers.G2DListCrossoverUniform) elif self.crossover == "type": # keep the same type of arguments together genome.crossover.set(Crossovers.G2DListCrossoverSingleHPoint) elif self.crossover == "node": # keep parameter of the same node together genome.crossover.set(Crossovers.G2DListCrossoverSingleVPoint) else: raise NotImplementedError ga = GSimpleGA.GSimpleGA(genome) if self.maximization: ga.setMinimax(Consts.minimaxType["maximize"]) else: ga.setMinimax(Consts.minimaxType["minimize"]) if self.selector == "tournament": ga.selector.set(Selectors.GTournamentSelector) elif self.selector == "roulette": ga.selector.set(Selectors.GRouletteWheel) else: raise NotImplementedError ga.setCrossoverRate(self.crossoverRate) ga.setMutationRate(self.mutationRate) ga.setPopulationSize(self.populationSize) ga.setGenerations(self.noGenerations) sqlite_adapter = DBAdapters.DBSQLite( dbname=self.databaseName, identify="default") # save statistics csv_adapter = DBAdapters.DBFileCSV( filename=self.csvName, identify="default") # save statistics ga.setDBAdapter(sqlite_adapter) #ga.setDBAdapter(csv_adapter) pop = ga.getPopulation() if self.scaling == "sigma": pop.scaleMethod.set(Scaling.SigmaTruncScaling) elif self.scaling == "exponential": pop.scaleMethod.set(Scaling.ExponentialScaling) elif self.scaling == "rank": pop.scaleMethod.set(GeneticTraining.rankScaling) # change Class elif self.scaling == "linear": pop.scaleMethod.set(GeneticTraining.linearScaling) # change Class else: raise NotImplementedError ga.setElitism(True) ga.setElitismReplacement(2) t_init = time.time() ga.evolve() t_tot = time.time() - t_init best = ga.bestIndividual() self.data = self.fetchData() #self.data = self.fetchCSVData() return best.genomeList, best.getRawScore(), t_tot
def __init__(self, datafile="filtered_data.txt", classes_file="classe.txt", output_file="filtered_data", generations=100, population_size=5, chromossome_lenght=4039, ga_selector="GRouletteWheel", optimization_method="distance", mutation_ratio=0.02, crossover_ratio=0.8, method_dist="euclidean", method_hclust="average", n_bootstrap=100, size_weight=2, groups_weight=1, bootstrap_weight=2, distance_ratio_weight=9, variation_weight=1, parallel=False, biosignature_max_size=50, biosignature_min_size=10, biosignature_min_acceptable_size=5, buffer_penalty=1, display_output=1, F_factor=0.2, ga_repetition=1, n_extremes_values=1): """ BioSig is a program developed to assist Biomarker discovery from microarray or proteomic data. Given samples belonging to different groups, find those variables (expressed mRNAs or proteins, for transcriptomic or proteomic analysis respectively) that, by a hierarchical clustering, could recovery those groups. The solution is optimized by a genetic algorithm procedure, implemented by pyevolve. Inputs: normalized and filtered data file name (argument: datafile); file containing the groups of each sample (classes_file); output filename (output_file); number of generations for the G.A. (generations); default: 100 population size for the G.A. (population_size); default: 5 chromossome lenght for the G.A. (chromossome_lenght); selector (ga_selector) optimization method (optimization_method): 'distance' or 'clustering'; default: clustering; mutation ratio (mutation_ratio); default: 0.8 crossover ratio(crossover_ratio); default: 0.02 distance method for hierachical clustering and distance calculation (method_dist); - for Hierarchical clustering clustering method for hierachical clustering (method_hclust); default: average; number of bootstrap pseudo replications for hierachical clustering (n_bootstrap); default: 100; weight for chromossome size ratio (size_weight), i.e., number of genes included (standardized); weight for bootstrap support (bootstrap_weight); weight for distance ratio (distance_ratio_weight); weight for F factor (F_factor), default: 0.2; - for Biosignature size biosignature_max_size, default: 50; biosignature_min_size, default: 10; biosignature_min_acceptable_size, default: 5; buffer_penalty, default: 1; display_output: 1 if GA progression should be displayed Output: those mRNA/proteins that gave best solution """ threading.Thread.__init__(self) #Define optimization parameters self.display_output = display_output self._independent_best_solution = -1000 self._independent_best_chromossome = [] self.optimization_method = optimization_method self.method_dist = method_dist self.method_hclust = method_hclust self.n_bootstrap = n_bootstrap self.parallel = parallel #Define I/O self.classes_file = classes_file self.data_file = datafile self.output_file = output_file self.output = open(self.output_file + ".txt", "w") self.plot_output_filename = output_file[:-4] + ".png" self.groups = self.parse_groups(self.classes_file) print "\nGroups and their Samples" for group, samples in self.groups.iteritems(): print group, samples #Define GA parameter self.chromossome_lenght = chromossome_lenght self.population_size = population_size self.generations = generations self.ga_selector = ga_selector self.mutation_ratio = mutation_ratio self.crossover_ratio = crossover_ratio #Define weights self.size_weight = size_weight self.groups_weight = groups_weight self.bootstrap_weight = bootstrap_weight self.distance_ratio_weight = distance_ratio_weight self.variation_weight = variation_weight self.F_factor = F_factor self.n_extremes_values = n_extremes_values #Define Bisignature size parameter self.biosigbiosignature_max_size = biosignature_max_size self.biosigbiosignature_min_size = biosignature_min_size self.biosigbiosignature_min_acceptable_size = biosignature_min_acceptable_size self.buffer_penalty = buffer_penalty #The next lines record analysis's parameters self.output.write("I/O parameters\n") self.output.write("\tInput data: %s\n" % datafile) self.output.write("\tOutput data: %s\n" % output_file) self.output.write("\tGroups data: %s\n" % classes_file) self.output.write("Genetic Algorithms parameters\n") self.output.write("\tChromossome Lenght: %s\n" % str(chromossome_lenght)) self.output.write("\tPopulation size: %s\n" % str(population_size)) self.output.write("\tGenerations: %s\n" % str(generations)) self.output.write("\tGA selector: %s\n" % str(ga_selector)) self.output.write("\tMutation Ratio: %s\n" % str(mutation_ratio)) self.output.write("\tCrossOver Ratio: %s\n" % str(crossover_ratio)) self.output.write("Weights parameters\n") self.output.write("\tSize weight: %s\n" % str(size_weight)) self.output.write("\tGroups weight: %s\n" % str(groups_weight)) self.output.write("\tBootstrap weight: %s\n" % str(bootstrap_weight)) self.output.write("\tDistance ratio weight: %s\n" % str(distance_ratio_weight)) self.output.write("\tVariation weight: %s\n" % str(variation_weight)) self.output.write("Biosignature size parameters\n") self.output.write("\tmax size: %s\n" % str(biosignature_max_size)) self.output.write("\tmin size: %s\n" % str(biosignature_min_size)) self.output.write("\tmin acceptable size: %s\n" % str(biosignature_min_acceptable_size)) self.output.write("\tBuffer penalty: %s\n" % str(buffer_penalty)) self.output.write("\tObjective Function parameters:") self.output.write("\tF-factor: %s\n" % str(F_factor)) self.output.write("\tNumber of extreme values included: %s\n" % self.n_extremes_values) self.output.write("\tDistance measure: %s\n" % self.method_dist) # load data from microarrays using RPy r('library("pvclust")') r('data <- read.table("%s", header=TRUE, row.names=1)' % self.data_file) r('data_sd <- sd(t(data))') #Getting and setting samples indexes and colors self.matrix_labels = r('colnames(data)') self.groups_indexes = {} self.samples_colors = [] self.get_sample_indexes_and_colors() #Creating group_median_matrix #this matrix will contain the median of each sonde for each group r('group_median_matrix <- matrix(nrow=nrow(data), ncol=%s)' % (str(len(self.groups.keys())))) r('dimnames(group_median_matrix)[[1]] <- labels(data)[[1]]') r('dimnames(group_median_matrix)[[2]] <- c(%s)' % str(self.groups.keys()).replace(" ", "")[1:-1]) #Creating within_group_dispersion_matrix #this matrix will contain the a dispersion measure of each sonde for each group r('within_group_dispersion_matrix <- matrix(nrow=nrow(data), ncol=%s)' % (str(len(self.groups.keys())))) r('dimnames(within_group_dispersion_matrix)[[1]] <- labels(data)[[1]]') r('dimnames(within_group_dispersion_matrix)[[2]] <- c(%s)' % str(self.groups.keys()).replace(" ", "")[1:-1]) #Creating between_groups_dispersion_matrix #this matrix will contain the a dispersion measure of each sonde among all groups r('between_groups_dispersion_matrix <- matrix(nrow=nrow(data), ncol=1)' ) r('dimnames(between_groups_dispersion_matrix)[[1]] <- labels(data)[[1]]' ) #Calculate group means and standard deviation print "\nGroups and their indexes" for group, indexes in self.groups_indexes.iteritems(): print group, indexes r('group_median_matrix[,"%s"] <- apply(data[,c(%s)],1,median)' % (group.strip(), str(indexes).replace(" ", "")[1:-1])) r('within_group_dispersion_matrix[,"%s"] <- apply(data[,c(%s)],1,IQR)' % (group.strip(), str(indexes).replace(" ", "")[1:-1])) r('between_groups_dispersion_matrix <- apply(group_median_matrix,1,IQR)' ) #Starting print "Dimensions of loaded data: ", r('dim(data)') print "Microarray data loaded" print "Setting G.A. parameters" self.genome = G1DList.G1DList(self.chromossome_lenght) if self.optimization_method == "clusters": self.genome.evaluator.set(self.check_clusters) self.output.write("Clustering: %s; Bootstrap: %s; Chromossome lenght: %s; Population size: %s; Generations: %s \n" \ %(method_hclust, str(n_bootstrap), str(chromossome_lenght), str(population_size), str(generations))) self.output.write("Groups weight: %s; Size weight: %s; Bootstrap weight: %s\n" \ %(str(self.groups_weight), str(self.size_weight), str(self.bootstrap_weight))) elif self.optimization_method == "distance": self.genome.evaluator.set(self.check_distance) self.output.write("Chromossome lenght: %s; Population size: %s; Generations: %s \n" \ %(str(chromossome_lenght), str(population_size), str(generations))) self.output.write("Distance weight: %s; Size weight: %s\n" \ %(str(self.distance_ratio_weight), str(self.size_weight))) self.genome.setParams(rangemin=0.0, rangemax=1.0) self.genome.crossover.set(Crossovers.G1DBinaryStringXTwoPoint) self.ga = GSimpleGA.GSimpleGA(self.genome, interactiveMode=False) self.ga.setPopulationSize(self.population_size) self.ga.setGenerations(self.generations) self.ga.selector.set(Selectors.GRouletteWheel) self.ga.setMutationRate(self.mutation_ratio) self.ga.setCrossoverRate(self.crossover_ratio)
def run_main(): # First arg -f name of the file that contains the results. # Second arg -s [0,1] if 1 then RouletteWheel elif 0 then Tournament # Third arg -e [0,1] if 1 then Elitism elif 0 then noElitism # Fourth arg -c the crossover rate # Fifth arg -m the mutation rate name = "GABIL_Results.txt" # Genome instance genome = G1DVariableBinaryString.G1DVariableBinaryString(ruleLength=60) # The evaluator function (objective function) genome.evaluator.set(fitness) genome.mutator.set(Mutators.G1DBinaryStringMutatorFlip) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.selector.set(Selectors.GTournamentSelector) ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) ga.setMultiProcessing() if len(sys.argv) > 1: if len(sys.argv[1:]) % 2 == 0: i = 1 while i < len(sys.argv): if sys.argv[i] == '-f': name = sys.argv[i+1] elif sys.argv[i] == '-s': if sys.argv[i+1] == '0': ga.selector.set(Selectors.GTournamentSelector) elif sys.argv[i+1] == '1': ga.selector.set(Selectors.GRouletteWheel) else: print "ERROR: Unknown argument!" sys.exit(1) elif sys.argv[i] == '-e': if sys.argv[i+1] == '0': ga.setElitism(False) elif sys.argv[i+1] == '1': ga.setElitism(True) else: print "ERROR: Unknown argument!" sys.exit(1) elif sys.argv[i] == '-c': try: crossoverRate = float(sys.argv[i+1]) ga.setCrossoverRate(crossoverRate) except ValueError: print "ERROR: Unknown argument!" sys.exit(1) elif sys.argv[i] == '-m': try: mutationRate = float(sys.argv[i+1]) ga.setMutationRate(mutationRate) except ValueError: print "ERROR: Unknown argument!" sys.exit(1) i += 2 else: print "ERROR: Incorrect number of arguments!" sys.exit(1) # GABIL. eval_func = 0 j = 1 for i in data_set[1:]: if eval_func == 0: ga.setGenerations(100*j) # Do the evolution, with stats dump # frequency of 10 generations print " ********************************************************************************" ga.evolve(freq_stats=10) print " ********************************************************************************" j += 1 if matches(ga.bestIndividual(),i): eval_func = 1 else: eval_func = 0 examples.append(i) f = open(name, 'a') f.write(str(ga.bestIndividual())) f.write("Prediccion " + str(predict(ga.bestIndividual().genomeList)) + "%" + "\n") f.close()
def test_fails_with_negative_evaluator(self): self.genome.evaluator.set(lambda _: -1) self.ga = GSimpleGA.GSimpleGA(self.genome) self.assertRaises(ValueError, self.ga.evolve, {'freq_stats': 1})
def checkStop( ga_engine=GSimpleGA.GSimpleGA(G1DList.G1DList()), stop_fname='.stop'): condition_1 = GSimpleGA.ConvergenceCriteria(ga_engine) fname = os.path.join(ga_folder(), stop_fname) condition_2 = os.path.exists(fname) return condition_1 or condition_2
def test_gp_mode_is_set_for_tree_genome(self): ga = GSimpleGA.GSimpleGA(GTreeGP()) self.assertTrue(ga.GPMode)
def test(): global day_index_test if day_index_test<all_row: #print day_index row=all_row[day_index_test:day_index_test+day*day_test] day_index_test=day_index_test+day*day_run-1 m=len(row) print m/54.0 #print m ## for z in row: ## print z ## def Open(i): return row[i][3] def High(i): return row[i][4] def Low(i): return row[i][5] def Close(i): return row[i][6] def Time(i): start=datetime.datetime(2014,1,1,0,0,0,0)+row[i][2] return start.strftime("%H:%M:%S") def Date(i): return row[i][0].strftime("%Y-%m-%d") def return_day_row(i): a=i-60 if a<0: a=0 b=i+60 if b>m: b=m if i<0: i=0 if i>m-1: i=m-1 n=[] for j in range(a,b): if cmp(Date(j),Date(i))==0: n.append(j) return n high_d=[] close_d=[] open_d=[] low_d=[] l=0 while(l<m): a=return_day_row(l) #print str(len(a))+'\n' b=[] c=[] for j in a: close_d.append(Close(a[-1])) open_d.append(Open(a[0])) b.append(High(j)) c.append(Low(j)) high=max(b) low=min(c) for z in a: high_d.append(high) low_d.append(low) l=len(high_d) def openD(i): #global open_d return open_d[i] def closeD(i): #global close_d return close_d[i] def lowD(i): #global low_d return low_d[i] def highD(i): #global high_d return high_d[i] def day_break(list_f): stop_percent=0.005 profit=[] totalprofit=[] entry_price=[] exit_price=[] Lots=1 entry_count=-1 exit_count=-1 con=0 day_con=0 status=0 for i in range(0,m): if i>=day*13: #print openD(0) if con==0: #print openD[0] s=0 for num in range(0,10): a=max(highD(i-day*(1+num)),closeD(i-day*(2+num))) b=min(lowD(i-day*(1+num)),closeD(i-day*(2+num))) s=s+(a-b) avetruerange=s/10.0 truehigh=max(highD(i-day),closeD(i-day*2)) truelow=min(lowD(i-day),closeD(i-day*2)) truerange=truehigh-truelow f=list_f[0]*openD(i-day)+list_f[1]*highD(i-day)+list_f[2]*lowD(i-day)+list_f[3]*closeD(i-day)+list_f[4]*closeD(i-day*2) f=f+list_f[5]*truehigh+list_f[6]*truelow+list_f[7]*truerange+list_f[8]*avetruerange up=Open(i)+f down=Open(i)-f ooo=Open(i) con=1 if High(i)>up and day_con==0: if status==0: #entry_count=entry_count+1 entry_price.append(max(up,Open(i))) entry_time=Time(i) #start=datetime.datetime(2014,1,1,0,0,0,0)+Time(i) #write(Date(i).strftime("%Y-%m-%d")+" "+start.strftime("%H:%M:%S")+" "+str(entry_price[-1])+"jin") status=1 day_con=1 if Low(i)<down and day_con==0: if status==0: #entry_count=entry_count+1 entry_time=Time(i) entry_price.append(min(down,Open(i))) #start=datetime.datetime(2014,1,1,0,0,0,0)+Time(i) #write(Date(i).strftime("%Y-%m-%d")+" "+start.strftime("%H:%M:%S")+" "+str(entry_price[-1])+"jin") status=-1 day_con=1 if status==1: stop=(1-stop_percent)*entry_price[-1] if Low(i)<stop and cmp(Time(i),entry_time)!=0: exit_price.append(min(Open(i),stop)) profit.append((exit_price[-1]-entry_price[-1])*Lots*300-23) totalprofit.append(sum(profit)) #start=datetime.datetime(2014,1,1,0,0,0,0)+Time(i) #write(Date(i).strftime("%Y-%m-%d")+" "+start.strftime("%H:%M:%S")+" "+str(exit_price[-1])+"ping") status=0 day_con=1 if status==-1: stop=(1+stop_percent)*entry_price[-1] if High(i)>stop and cmp(Time(i),entry_time)!=0: #exit_count=exit_count+1 exit_price.append(max(Open(i),stop)) profit.append((entry_price[-1]-exit_price[-1])*Lots*300-23) totalprofit.append(sum(profit)) #start=datetime.datetime(2014,1,1,0,0,0,0)+Time(i) #write(Date(i).strftime("%Y-%m-%d")+" "+start.strftime("%H:%M:%S")+" "+str(exit_price[-1])+"ping") status=0 day_con=1 if cmp(Time(i),"15:00:00")==0: con=0 day_con=0 if status==1: exit_price.append(Close(i)) profit.append((exit_price[-1]-entry_price[-1])*Lots*300-23) totalprofit.append(sum(profit)) #start=datetime.datetime(2014,1,1,0,0,0,0)+Time(i) #write(Date(i).strftime("%Y-%m-%d")+" "+start.strftime("%H:%M:%S")+" "+str(exit_price[-1])+"ping_rimo") status=0 if status==-1: #exit_count=exit_count+1 exit_price.append(Close(i)) profit.append((entry_price[-1]-exit_price[-1])*Lots*300-23) totalprofit.append(sum(profit)) #start=datetime.datetime(2014,1,1,0,0,0,0)+Time(i) #write(Date(i).strftime("%Y-%m-%d")+" "+start.strftime("%H:%M:%S")+" "+str(exit_price[-1])+"ping_rimo") status=0 if len(totalprofit)!=0: return totalprofit[-1]+100000000 else: return 100000000 genome = G1DList.G1DList(9) genome.setParams(rangemin=-2.0, rangemax=2.0) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealGaussian) #genome.crossover.clear() # The evaluator function (objective function) genome.evaluator.set(day_break) #genome.evaluator.add(func_1) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.selector.set(Selectors.GRouletteWheel) ga.setMutationRate(0.98) ga.setPopulationSize(50) #ga.setCrossoverRate(0.8) ga.setGenerations(100) #ga.stepCallback.set(evolve_callback) # Do the evolution ga.evolve(10) best=ga.bestIndividual() return best.genomeList
def setUp(self): self.genome = G1DList.G1DList(2) self.genome.evaluator.set(lambda _: 0) self.ga = GSimpleGA.GSimpleGA(self.genome)
genome.initializator.set(init_pop) # Set mutator function genome.mutator.set(Mutators.G1DListMutatorSwap) # Set Crossover function genome.crossover.set(Crossovers.G1DListCrossoverCutCrossfill) genome.evaluator.set(fitness_func) crossover_rate = [] fitness_value = [] best_value = [1, 1] for x in numpy.arange(150, 500, 10): ga = GSimpleGA.GSimpleGA(genome) # ga.setPopulationSize(20) ga.setPopulationSize(50) ga.selector.set(Selectors.GTournamentSelector) ga.setMutationRate(0.02) ga.setCrossoverRate(0.9) # Set type of objective/ fitness function: Convergence ga.setMinimax(Consts.minimaxType["minimize"]) ga.setGenerations(x) ga.evolve() best = ga.bestIndividual() # print best.score if check_precedence_criteria(list(best)) == True: print "X: ", x, best.fitness if best.fitness < best_value[1]: best_value = [x, best.fitness]
def st_ga1(objfunc, par_b, par_n, scale, offset): import pylab as pl try: import pyevolve as pe from pyevolve import GSimpleGA, G1DList, Initializators, Crossovers, Selectors, Mutators, Scaling, Consts except ImportError: pe = None assert pe is not None, 'Library for pyevolve is not installed' lb = [v[0] for v in par_b] # Normalised lower bound ub = [v[1] for v in par_b] # Normalised upper bound ind_size = len(par_n) # Number of design parameters pop_size = 100 # Set number of individuals in population ngen = 2 # Total number of generation to run cxpb = 0.98 # Crossover probability mutpb = 0.01 # Mutation probability freq_stats = 10 # Frequency of stats paral_eval = False # To enable parallel evaluation. Only use it when the fitness function is slow! pl.ion() genome = G1DList.G1DList(ind_size) # Genome instance genome.setParams( rangemin=lb[0], rangemax=ub[0]) # Set the range min and max of the 1D List genome.evaluator.set( objfunc) # The evaluator function (fitness/objective function) genome.initializator.set(Initializators.G1DListInitializatorReal ) # Real initialization function of G1DList genome.crossover.set( Crossovers.G1DListCrossoverUniform) # The G1DList Uniform Crossover genome.mutator.set(Mutators.G1DListMutatorRealRange ) # Simple real range mutator for G1DList ga = GSimpleGA.GSimpleGA(genome) # Genetic algorithm instance ga.selector.set(Selectors.GTournamentSelector) # Set the selector method ga.setMinimax(Consts.minimaxType["minimize"]) #if framework == 'soo_min': # ga.setMinimax(Consts.minimaxType["minimize"]) #else: # ga.setMinimax(Consts.minimaxType["maximize"]) ga.setPopulationSize( pop_size) # Set the population size for each generation ga.setGenerations(ngen) # Set the number of generation ga.setCrossoverRate(cxpb) # Set the crossover rate ga.setMutationRate(mutpb) # Set the mutation rate ga.terminationCriteria.set( GSimpleGA.ConvergenceCriteria ) # Terminate the evolution when the population have converged pop = ga.getPopulation() # Return the internal population of GA Engine pop.scaleMethod.set( Scaling.SigmaTruncScaling ) # Sigma Truncation scaling scheme, allows negative scores ga.evolve( freq_stats=freq_stats ) # Run the optimisation and print the stats of the ga every n generation ga.setMultiProcessing( flag=paral_eval, full_copy=False ) # Set the flag to enable/disable the use of python multiprocessing module res = ga.bestIndividual() # Best individual in normalised form cand = [scale[i] * v + offset[i] for i, v in enumerate(res.genomeList) ] # Denormalised best individual return res.score, cand