def run_main(): genome = G1DList.G1DList(BOARD_SIZE) genome.setParams(bestrawscore=BOARD_SIZE, rounddecimal=2) genome.initializator.set(queens_init) genome.mutator.set(Mutators.G1DListMutatorSwap) genome.crossover.set(Crossovers.G1DListCrossoverCutCrossfill) genome.evaluator.set(queens_eval) ga = GSimpleGA.GSimpleGA(genome) ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) ga.setMinimax(Consts.minimaxType["maximize"]) ga.setPopulationSize(100) ga.setGenerations(250) ga.setMutationRate(0.02) ga.setCrossoverRate(1.0) #sqlite_adapter = DBAdapters.DBSQLite(identify="queens") #ga.setDBAdapter(sqlite_adapter) vpython_adapter = DBAdapters.DBVPythonGraph(identify="queens", frequency=1) ga.setDBAdapter(vpython_adapter) ga.evolve(freq_stats=10) best = ga.bestIndividual() print best print "Best individual score: %.2f\n" % (best.getRawScore(),)
def run_main(): # Genome instance genome = G1DList.G1DList(5) genome.setParams(rangemin=0.0 * math.pi / 180, rangemax= 15.0 * math.pi / 180, gauss_sigma = 5 * math.pi / 180) # Change the initializator to Real values genome.initializator.set(Initializators.G1DListInitializatorReal) # Change the mutator to Gaussian Mutator genome.mutator.set(Mutators.G1DListMutatorRealGaussian) # The evaluator function (objective function) genome.evaluator.set(eval_func) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) sqlite_adapter = DBAdapters.DBSQLite(identify=sys.argv[1]) ga.setDBAdapter(sqlite_adapter) ga.selector.set(Selectors.GRankSelector) ga.setSortType(Consts.sortType["raw"]) ga.setGenerations(50) ga.setPopulationSize(10) ga.setMutationRate(1./5/3) ga.setMinimax(Consts.minimaxType['minimize']) print ga # Do the evolution ga.evolve(freq_stats=1) # Best individual print ga.bestIndividual()
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 ga.evolve(freq_stats=20) # Best individual print(ga.bestIndividual())
def findSol(self, timewindow): pyevolve.logEnable() genome = G1DList.G1DList(4) # range is constrained by the solutions found by MR genome.setParams(rangemin=-12.0, rangemax=2.0) # Change the initializator to Real Values genome.initializator.set(Initializators.G1DListInitializatorReal) # Change the mutator to Gaussian genome.mutator.set(Mutators.G1DListMutatorRealGaussian) # The evaluator function (objective function) genome.evaluator.set(self.eval_func(self.features)) genome.crossover.set(Crossovers.G1DListCrossoverTwoPoint) # 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) # set default parameters for the engine ga.setGenerations(100) #ga.setPopulationSize(80) #ga.setMutationRate(0.2) #ga.setCrossoverRate(0.8) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setElitism(True) 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) dbPath = createPath('pyevolve.db') sqlite_adapter = DBAdapters.DBSQLite(dbname=dbPath, identify="timewindow" + str(timewindow), resetIdentify=True, resetDB=False) ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump frequency of 20 generations ga.evolve(freq_stats=20) # Best individual best = ga.bestIndividual() stats = { 'constant': best[0], 'EMA': best[1], 'RSI': best[2], 'MACD': best[3] } return stats
def main(argv): global coords cm = [] cities = [] # read cities from file given as a argument into a list of dictionaries with open(argv[1]) as f: for i in xrange(7): f.next() for line in f: words = line.split(" ") cities.append({ "num": words[0], "x": words[1], "y": words[2].strip() }) # put coordinates into a form best suited for the funtion to parse coords = [(float(c['x']), float(c['y'])) for c in cities] cm = cartesian_matrix(coords) genome = G1DList.G1DList(len(coords)) # initialize evaluation function and crossover function genome.evaluator.set( lambda chromosome: tour_length(cm, chromosome, len(cities))) genome.crossover.set( Crossovers.G1DListCrossoverEdge ) # choices are G1DListCrossoverEdge (A) or G1DListCrossoverCutCrossfill (B) genome.initializator.set(G1DListTSPInitializator) ga = GSimpleGA.GSimpleGA(genome) # set up database to generate improvment curve graph after genetic algorithm sqlite_adapter = DBAdapters.DBSQLite(identify="ex1") ga.setDBAdapter(sqlite_adapter) # initialized genetic algorithm variables (generations, crossover rate, mutation rate, and population size) ga.setGenerations(200000) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(1.0) ga.setMutationRate(0.002) # choises are 0.02 (1) or 0.002 (2) ga.setPopulationSize(80) ga.evolve(freq_stats=500) best = ga.bestIndividual() # graph and print the best route write_tour_to_img(coords, best, "tsp_result.png") print(best)
def run_main(): # Genome instance genome = G1DBinaryString.G1DBinaryString(bitstrlen) # The evaluator function (objective function) # genome.evaluator.set(eval_func) genome.evaluator.set(eval_func_onhardware) genome.mutator.set(Mutators.G1DBinaryStringMutatorFlip) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) #ga.setElitism(True) ga.setMutationRate(0.02) # for use with long strings 0.01, default: 0.02 ga.selector.set(Selectors.GTournamentSelector) ga.setPopulationSize(10) ga.setGenerations(30) # ga.setInteractiveGeneration(10) csv_adapter = DBAdapters.DBFileCSV(identify="run1", filename="stats.csv") ga.setDBAdapter(csv_adapter) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=1) # Best individual print ga.bestIndividual() print "target:", target.bin print "date:" # do timings of all components: bitgen, eval, f = open("best-ind.txt", "w") f.write(str(ga.bestIndividual())) f.write("\n") f.write(str(target.bin)) f.write("\n") f.close()
def run(): """ run the pipeline """ global google_api_key google_api_key = get_key() start_logging() genome = GoogleQueryGenome(seq_length) print genome genome.evaluator.set(count_results_by_query) # genome.setParams(rangemin=rangemin, rangemax=rangemax) genome.initialize() ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(ngenerations) # ga.setMultiProcessing() csv_adapter = DBAdapters.DBFileCSV(identify="testrun", filename='results/testrun.csv') ga.setDBAdapter(csv_adapter) # ga.StepCallback.set(pickle_generation) ga.evolve(freq_stats=10) print "*"*5 + "best individual:" print ga.bestIndividual()
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()
# Genome instance genome = G1DList.G1DList(5) genome.setParams(rangemin=0, rangemax=31) # The evaluator function (objective function) genome.evaluator.set(eval_func) ga = GSimpleGA.GSimpleGA(genome) ga.setDBAdapter( DBAdapters.DBSQLite( identify="ex1" ) ) ga.setGenerations(9) ga.setPopulationSize(50) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=10) # Best individual print ga.bestIndividual()
from pyevolve import G1DList from pyevolve import GSimpleGA from pyevolve import Selectors from pyevolve import DBAdapters import pyevolve def eval_func(chromosome): score = 0.0 for value in chromosome: if value == 0: score += 1 return score pyevolve.logEnable() genome = G1DList.G1DList(50) genome.setParams(rangemin=0, rangemax=10) genome.evaluator.set(eval_func) ga = GSimpleGA.GSimpleGA(genome) ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(500) ga.setPopulationSize(10) ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) csv_adapter = DBAdapters.DBFileCSV(identify="run1", filename="statsfyuk.csv") ga.setDBAdapter(csv_adapter) ga.evolve(freq_stats=20) 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
l = [] for point in pontos: try: l.append(min(map(distance, centroid, [point] * NUM_GROUPS))) except: print genome, centroid, [point] * NUM_GROUPS return 1000.0 / reduce(lambda a, b: a + b, l, 0.0) pontos = open("dados_ECC1.txt").read().split('\n') pontos = [map(float, i.split(' ')) for i in pontos if i <> ''] sqlite_adapter = DBAdapters.DBSQLite(identify="l1q2_1", resetDB=False) genome = G1DList.G1DList(12) genome.setParams(rangemin=1.0, rangemax=7.0) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealGaussian) genome.crossover.set(L1Q2ArithCrossover) genome.evaluator.set(fitness_func) ga = GSimpleGA.GSimpleGA(genome) ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) ga.selector.set(Selectors.GTournamentSelector) ga.setPopulationSize(100) ga.setGenerations(200) ga.setCrossoverRate(0.9) ga.setMutationRate(0.02)
ga.setPopulationSize(pop_var) #ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) ga.terminationCriteria.set(convergence1) ga.setMultiProcessing(True, False, 48) #ga.setElitism(True) #ga.evolve(freq_stats=1) ga.elitism = True ## Gen time taken # Do the evolution, with stats dump # frequency of 10 generations time.ctime() sqlite_adapter = DBAdapters.DBSQLite(identify="gen_10_pop_" + time_label, resetDB=True, resetIdentify=True, frequency=1, commit_freq=1) #sqlite_adapter.setStatsGenFreq(1) ga.setDBAdapter(sqlite_adapter) ga.evolve(1) pd.DataFrame(Gen_time_taken).to_excel('Gen_time_taken' + time_label + '.xlsx') ##ga.evolve(freq_stats=1) ###%run pyevolve_graph.py -i gen_10_pop_500_02_03_2018_16_00_overnight1_initial -1 -o graph_gen_10_pop_500_02_03_2018_16_00_overnight_initial -e pdf #sqlite_adapter.open(ga) #sqlite_adapter.insert(ga) #sqlite_adapter.commitAndClose()
def main(argv): start = time.time() global coords cm = [] cities = [] crowd = [] finalRoute = [] current = 0 # read cities from file given as a argument into a list of dictionaries with open(argv[1]) as f: for i in xrange(7): f.next() for line in f: words = line.split(" ") cities.append({ "num": words[0], "x": words[1], "y": words[2].strip() }) # put coordinates into a form best suited for the funtion to parse coords = [(float(c['x']), float(c['y'])) for c in cities] cm = cartesian_matrix(coords) genome = G1DList.G1DList(len(coords)) # initialize evaluation function and crossover function genome.evaluator.set( lambda chromosome: tour_length(cm, chromosome, len(cities))) genome.crossover.set( Crossovers.G1DListCrossoverEdge ) # choices are G1DListCrossoverEdge (A) or G1DListCrossoverCutCrossfill (B) genome.initializator.set(G1DListTSPInitializator) ga = GSimpleGA.GSimpleGA(genome) # set up database to generate improvment curve graph after genetic algorithm sqlite_adapter = DBAdapters.DBSQLite(identify="ex1") ga.setDBAdapter(sqlite_adapter) # initialized genetic algorithm variables (generations, crossover rate, mutation rate, and population size) ga.setGenerations(10000) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(1.0) ga.setMutationRate(0.002) # choises are 0.02 (1) or 0.002 (2) ga.setPopulationSize(80) ga.evolve(freq_stats=500) pop = ga.getPopulation() best = ga.bestIndividual() # graph and print the best route write_tour_to_img(coords, best, "tsp_result.png") print(best) # initialize a matrix to perform a wisom of crowds analysis for i in xrange(len(cities)): nestedList = [] for j in xrange(len(cities)): nestedList.append(0) crowd.append(nestedList) # populate matrix with occuences of specific edges for i in xrange(20): for j in xrange(len(cities)): if j + 1 == len(cities): minimum = min(pop[i][j], pop[i][0]) maximum = max(pop[i][j], pop[i][0]) crowd[minimum][maximum] += 1 else: minimum = min(pop[i][j], pop[i][j + 1]) maximum = max(pop[i][j], pop[i][j + 1]) crowd[minimum][maximum] += 1 # find best path from wisdom of crowds finalRoute.append(0) while (len(finalRoute) < len(cities)): x, wisdom = 0, 0 for i in xrange(len(cities)): minimum = min(current, i) maximum = max(current, i) if crowd[minimum][maximum] > wisdom and i not in finalRoute: wisdom = crowd[minimum][maximum] x = i current = x finalRoute.append(current) print finalRoute print 'woc Score: %s' % woc_score(coords, finalRoute) write_tour_to_img(coords, finalRoute, "woc_result.png") # print time for script to run print '\nThis script took ', time.time() - start, ' seconds.'
def eval_func(chromosome): i = np.array(chromosome.genomeList)[np.newaxis, :, :] return float(np.squeeze(n.run(i, channel, layer))) genome = G2DList.G2DList(cfg.layerTestSizes[layer], cfg.layerTestSizes[layer]) genome.setParams(rangemin=0, rangemax=1, gauss_mu=0, gauss_sigma=1) genome.evaluator.set(eval_func) genome.crossover.set(Crossovers.G2DListCrossoverUniform) genome.mutator.set(Mutators.G2DListMutatorRealGaussian) ga = GSimpleGA.GSimpleGA(genome) # ga.selector.set(Selectors.GRouletteWheel) ga.setPopulationSize(NPop) ga.setGenerations(NGen) csvfile_adapter = DBAdapters.DBFileCSV(filename="%s/%i_%i.csv" % (outDir, layer, channel), frequency=NGen / 10) ga.setDBAdapter(csvfile_adapter) # sqlite_adapter = DBAdapters.DBSQLite(identify="%i_%i" % (layer, channel),frequency=NGen/10) # ga.setDBAdapter(sqlite_adapter) ga.evolve(freq_stats=NGen / 10) bi = ga.bestIndividual() pl.imsave('%s/ga_%i.png' % (outDir, NGen), np.array(bi.genomeList), cmap=pl.cm.gray)
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 vars. ga.setCrossoverRate(1.0) ga.setMutationRate(0.08) ga.setPopulationSize(80) ga.setGenerations(500) ga.setMultiProcessing(False) # buggy when True # ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) # Sets the DB Adapter, the resetDB flag will make the Adapter recreate # the database and erase all data every run. Doesn't seem to actually # use the DB even when False. sqlite_adapter = DBAdapters.DBSQLite(identify="ex1", resetDB=True) ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 20 generations ga.evolve(freq_stats=2) # Best individual print ga.bestIndividual()
def attach_db(self, path): sqlite_adapter = DBAdapters.DBSQLite(dbname=path, identify="ex1", resetDB=True, commit_freq=1) self._ga.setDBAdapter(sqlite_adapter)
# genome = bitstring genome.initializator.set(G1DListTSPInitializator) genome.setParams(rangemin=0, rangemax=13) # how to compute the fitness genome.evaluator.set(fitness) # GA initialisation ga = GSimpleGA.GSimpleGA(genome, seed=123) ga.setPopulationSize(100) ga.setMutationRate(0.01) ga.setCrossoverRate(0.9) ga.selector.set(Selectors.GTournamentSelector) ga.setElitism(True) sqlite_adapter = DBAdapters.DBSQLite(identify="tsp") ga.setDBAdapter(sqlite_adapter) # Number of generations ga.setGenerations(250) # In case we want to monitor the evolution process # execute the function current_best every generation #ga.stepCallback.set(current_best) ga.evolve(freq_stats=10) # Final best solution print ga.bestIndividual() totalDist = 0.0 for i in xrange(len(ga.bestIndividual())): start = (LAT[ga.bestIndividual()[i]], LON[ga.bestIndividual()[i]])
def run_GA(model, options=None): """Runs the genetic algorithm. See function ga_options for the contents of the options variable.""" global _model _model = model genome = pu.make_alleles_genome(model.genes) genome.evaluator.set(_fitness) genome.setParams(bestrawscore=options.term_fitness, num_trials=options.num_trials, initial_population=options.initial_population) if options.MPI: from sg.utils.pyevolve_mpi import SimpleMPIGA ga = SimpleMPIGA(model, genome, seed=options.seed) if not is_mpi_slave(options): print "MPI-distributed evolution with %d hosts." % ga.nhosts _print_mpi_info() else: ga = pu.SimpleGAWithFixedElitism(genome, seed=options.seed) if not is_mpi_slave(options): _print_mkl_info() ga.setGenerations(options.generations) _step_callbacks.append(make_dataset_stepper(model)) ga.stepCallback.set(step_generation) # Number of generations and dataset stepper must be set before starting eval_loop if is_mpi_slave(options): ga.eval_loop() return if options.initial_population is None: ga.setPopulationSize(options.pop_size) ga.setMutationRate(options.mutation) ga.setCrossoverRate(options.crossover) if options.elite > 0: ga.setElitism(True) ga.setElitismReplacement(options.elite) else: ga.setElitism(False) # DO NOT USE TOURNAMENT SELECTION WITH MINIMIZATION PROBLEMS (as of version # 0.6rc1 of Pyevolve), it selects max fitness irrespective of minimax mode. #ga.selector.set(Selectors.GTournamentSelector) ga.selector.set(Selectors.GRouletteWheel) #ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) # ga.getPopulation().scaleMethod.set(Scaling.SigmaTruncScaling) pop = ga.getPopulation() #pop.scaleMethod.set(pu.BoltzmannScalingFixed) pop.scaleMethod.set(pu.ExponentialScaler(options.generations)) boltz_start = pop.getParam("boltz_temperature", Consts.CDefScaleBoltzStart) boltz_min = pop.getParam("boltz_min", Consts.CDefScaleBoltzMinTemp) pop.setParams(boltz_factor=(boltz_start - boltz_min) / (0.8 * options.generations)) ga.setMinimax(Consts.minimaxType["maximize"]) print "Evolution settings:" print "\tNumber of training sequences: %d" % options.num_trials print "\tStart days of training sequences:", model.dataset.train_periods_desc print "\tTermination fitness: %f" % options.term_fitness print "\tRandom seed: %d" % options.seed print "\tPopulation size: %d" % ga.getPopulation().popSize print "\tNumber of generations: %d" % ga.getGenerations() print "\tNumber of elite indivs: %d" % options.elite print "\tCrossover rate: %f" % options.crossover # print "\tMutation rate (mu, sigma): %f (%f, %f)" % \ # (options.mutation, options.mutation_mu, options.mutation_sigma) print "\tMutation rate: %f" % options.mutation print "\tSelection mechanism(s): ", ga.selector[:] dbpath = sg.utils.get_path(options, "pyevolve", "db") sqlite_adapter = DBAdapters.DBSQLite(dbname=dbpath, identify="ex1", resetDB=True, commit_freq=1) ga.setDBAdapter(sqlite_adapter) if options.parallel: ga.setMultiProcessing(True) if options.print_pop: _step_callbacks.append(print_population) if options.live_plot: global _live_fig _step_callbacks.append(plot_fitnesses) _live_fig = plt.figure() plt.ion() if options.gui: _step_callbacks.append(update_gui) _step_callbacks.append(print_best_genome) _step_callbacks.append(report_time_spent) ga.evolve(freq_stats=1) model.genome = ga.bestIndividual() return
def run_main(): # Global runner instance that will also be used by eval_func global runner global log # "Settings" working_dir = '../work' log_dir = '../log' compare_values = '../ext/Detalierte Mechanismus.csv' log = Logger() log.setLogLevel('debug') # load parameter format defines from parameters.py import parameters pformat = parameters.parameter_format # load KivaRunner l = Logger() l.setLogLevel('info') runner = KivaRunner(working_dir, log_dir, compare_values, pformat, l) if runner.error: return # Genome instance setOfAlleles = GAllele.GAlleles() # loop trough parameter format to create correct alleles for p in pformat: minimum = p[2] maximum = p[3] # log.debug("maximum: %s, minimum: %s" % (maximum, minimum)) a = GAllele.GAlleleRange(minimum, maximum, not isinstance(minimum, int)) setOfAlleles.add(a) genome = G1DList.G1DList(len(pformat)) genome.setParams(allele=setOfAlleles) # The evaluator function (objective function) genome.evaluator.set(eval_func) # 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(G1DListInitializatorAlleleKiva) genome.initializator.set(Initializators.G1DListInitializatorAllele) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(10) ga.setPopulationSize(20) ga.setMinimax(Consts.minimaxType["minimize"]) # ga.setCrossoverRate(1.0) ga.setMutationRate(0.1) ga.selector.set(Selectors.GRouletteWheel) sqlite_adapter = DBAdapters.DBSQLite(identify="ex1", resetDB=True) ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=1) # Best individual best = ga.bestIndividual() print "\nBest individual score: %.2f" % (best.getRawScore(), ) print best
return sum1 # Genome instance genome = G1DList.G1DList(20) genome.setParams(rangemin=0, rangemax=10, bestRawScore=0.0) genome.mutator.set(Mutators.G1DListMutatorIntegerRange) # The evaluator function (objective function) genome.evaluator.set(rosenbrock) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.minimax = Consts.minimaxType["minimize"] ga.setGenerations(4000) ga.setMutationRate(0.2) ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) # Create DB Adapter and set as adapter sqlite_adapter = DBAdapters.DBSQLite(identify="rosenbrock") ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=200) # Best individual best = ga.bestIndividual() print "\nBest individual score: %.2f" % (best.score,) print best
error = 1 for index, row in subset.iterrows(): cip_predicted = expert.predict(row) cip_actual = df_actual.loc[index]["cust Investment Potential Score"] error += abs(cip_actual-cip_predicted) return 100/error; else: return 0 def t_init(genome, **args): genome.genomeList = chromosome_ #t_init(genome) genome.evaluator.set(eval_func) genome.mutator.set(Mutators.G1DListMutatorAllele) genome.initializator.set(t_init) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.setPopulationSize(100) ga.setGenerations(100) sqlite_adapter = DBAdapters.DBSQLite(identify="ex6") ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 1 generations ga.evolve(freq_stats=1) # Best individual 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 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
genome = G1DList.G1DList(5) genome.setParams(allele=setOfAlleles) genome.evaluator.set(heston_evaluate) genome.mutator.set(Mutators.G1DListMutatorAllele) genome.initializator.set(Initializators.G1DListInitializatorAllele) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) # ga.setGenerations(100) # ga.setPopulationSize(100) # ga.setMutationRate(0.01) # ga.setCrossoverRate(0.90) ga.minimax = Consts.minimaxType["minimize"] # ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) id = 'default-11' sqlite_adapter = DBAdapters.DBSQLite(identify="heston-" + id, resetIdentify=True, resetDB=False) ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=5) # Best individual print ga.bestIndividual() f = file('output-' + id + '.txt', 'w') f.write(str(ga.bestIndividual())) f.close()