def run_ga(fast): """Initialize and run the genetic algorithms.""" alleles = GAllele.GAlleles() # create list of all alleles alleles.add(GAllele.GAlleleRange(1, 1000)) # range for the number of days alleles.add(GAllele.GAlleleRange(1, 20)) # range for hidden nodes alleles.add(GAllele.GAlleleRange(1, 10)) # number of epochs alleles.add(GAllele.GAlleleList([True, False])) # bias alleles.add( GAllele.GAlleleList([float(x * Decimal("0.1")) for x in range(0, 10)])) # momentum alleles.add(GAllele.GAlleleList([TanhLayer, SigmoidLayer])) # tanh/sigmoid genome = G1DList.G1DList(len(alleles)) genome.setParams(allele=alleles, fast=fast) genome.evaluator.set(eval_func) genome.mutator.set(Mutators.G1DListMutatorAllele) genome.initializator.set(Initializators.G1DListInitializatorAllele) gen_alg = GSimpleGA.GSimpleGA(genome) gen_alg.setMultiProcessing(not fast) gen_alg.selector.set(Selectors.GRouletteWheel) gen_alg.setGenerations(20) gen_alg.evolve(freq_stats=0) return gen_alg.bestIndividual()
def fit(self,X,y,**param): self.neural_shape = param.get("neural_shape") self.n_input = self.neural_shape[0] self.n_output = self.neural_shape[-1] self.n_hidden = self.neural_shape[1] self.number_of_weights = self.n_hidden*(self.n_input+1)+self.n_output*(self.n_hidden+1) self.score_fn = FeedFlow(self.neural_shape) self.X = X self.y = y #setting params self.weights = G1DList.G1DList(self.number_of_weights) lim = np.sqrt(6)/np.sqrt((self.n_input+self.n_output)) #Khoi tao trong so self.weights.setParams(rangemin=-lim,rangemax=lim) # cai dat ham khoi tao self.weights.initializator.set(Initializators.G1DListInitializatorReal) #cai dat ham dot bien self.weights.mutator.set(Mutators.G1DListMutatorRealGaussian) #cai dat ham do thich nghi self.weights.evaluator.set(self.eval_score) # cai dat ham lai ghep self.weights.crossover.set(Crossovers.G1DListCrossoverUniform) #code genetic # thiet lap he so lai ghep self.ga = GSimpleGA.GSimpleGA(self.weights) self.ga.selector.set(Selectors.GRouletteWheel) self.ga.setMutationRate(self.mutation_rate) self.ga.setCrossoverRate(self.cross_rate) self.ga.setPopulationSize(self.pop_size) self.ga.setGenerations(self.pop_size) self.ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) self.ga.evolve(freq_stats=self.freq_stats) self.best_archive = self.getParam() return self
def run_main(): # Genome instance genome = G1DList.G1DList(1) genome.setParams(rangemin=-60.0, rangemax=60.0) # Change the initializator to Real values genome.initializator.set(Initializators.G1DListInitializatorReal) # Change the mutator to Gaussian Mutator genome.mutator.set(Mutators.G1DListMutatorRealGaussian) # Removes the default crossover genome.crossover.clear() # The evaluator function (objective function) genome.evaluator.set(eval_func) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.setMinimax(Consts.minimaxType["minimize"]) pop = ga.getPopulation() pop.scaleMethod.set(Scaling.SigmaTruncScaling) ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(100) # Do the evolution ga.evolve(10) # Best individual print(ga.bestIndividual())
def main_run(): global cm, coords, WIDTH, HEIGHT coords = [(random.randint(0, WIDTH), random.randint(0, HEIGHT)) for i in xrange(CITIES)] cm = distance_matrix(coords) genome = G1DList.G1DList(len(coords)) genome.evaluator.set(lambda chromosome: total_length(cm, chromosome)) """ Set different crossover methods in order to observe different fitness results """ genome.crossover.set(Crossovers.G1DListCrossoverUniform) genome.initializator.set(TSP_Init) ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(2000) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(1.0) ga.setMutationRate(0.02) """ Set different population sizes in order to observe different fitness results """ ga.setPopulationSize(40) ga.evolve(freq_stats=500) best = ga.bestIndividual() plot_and_save_file(coords, best, "tsp.png")
def solve(): setOfAlleles = GAllele.GAlleles(homogeneous=True) lst = [i for i in xrange(len(points))] a = GAllele.GAlleleList(lst) setOfAlleles.add(a) genome = G1DList.G1DList(len(points)) genome.setParams(allele=setOfAlleles) genome.evaluator.set(eval_func) genome.mutator.set(Mutators.G1DListMutatorSwap) genome.crossover.set(Crossovers.G1DListCrossoverOX) genome.initializator.set(tsp_initializator) ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(1000) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(1.0) ga.setMutationRate(0.03) ga.setPopulationSize(80) ga.evolve(freq_stats=100) best = ga.bestIndividual() best.append(best[0]) for i in range(len(best) - 1): canvas.create_line(points[best[i]].x, points[best[i]].y, points[best[i + 1]].x, points[best[i + 1]].y)
def cal_opt(numParm, fintness, strategyName, func, stock_data, stockName): if (strategyName == 'MACD' or strategyName == 'DMA') and 'Low' in stock_data.columns: datarange = [[8, 15], [21, 31], [6, 12]] elif (strategyName == 'MACD' or strategyName == 'DMA') and 'Low' not in stock_data.columns: datarange = [[3, 20], [21, 41], [5, 20]] else: datarange = [[2, 5], [6, 19], [7, 60]] datarange = datarange[:numParm] genome = G1DList.G1DList(numParm) genome.evaluator.set(func(fintness, strategyName, 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(40) ga.setGenerations(40) ga.setCrossoverRate(0.8) ga.setMutationRate(0.18) 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, round(best.score, 5)]
def main_run(): global cm, coords # load the tsp data file filehandle = open("instancias.txt", "r+") coords = read_file(filehandle) cm = cartesian_matrix(coords) # set the alleles to the cities numbers setOfAlleles = GAllele.GAlleles(homogeneous=True) lst = [i for i in xrange(len(coords))] a = GAllele.GAlleleList(lst) setOfAlleles.add(a) genome = G1DList.G1DList(len(coords)) genome.setParams(allele=setOfAlleles) genome.evaluator.set(eval_func) genome.mutator.set(Mutators.G1DListMutatorSwap) genome.crossover.set(Crossovers.G1DListCrossoverOX) genome.initializator.set(G1DListTSPInitializator) ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(1000) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(1.0) ga.setMutationRate(0.03) ga.setPopulationSize(80) ga.evolve(freq_stats=100) best = ga.bestIndividual() write_tour_to_img(coords, best, "tsp_result.png")
def get_best_individual(): # Genome instance, 1D List of 50 elements genome = G1DList.G1DList(mn.listLength) # Sets the range max and min of the 1D List genome.setParams(rangemin=mn.rangeMin, rangemax=mn.rangeMax, bestrawscore=0.0000) # The evaluator function (evaluation function) genome.evaluator.set(eval_func) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.setMinimax(Consts.minimaxType["minimize"]) # set the Roulette Wheel selector method, the number of generations and # the termination criteria ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(mn.noOfGeneration) ga.setMutationRate(mn.mutationRate) ga.setCrossoverRate(mn.crossoverRate) ga.setPopulationSize(mn.populationSize) ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) # ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria) pop = ga.getPopulation() pop.scaleMethod.set(Scaling.SigmaTruncScaling) # Do the evolution, with stats dump # frequency of 20 generations ga.evolve() # Best individual return ga.bestIndividual()
def save(fname="ga_run", ga_engine=GSimpleGA.GSimpleGA(G1DList.G1DList()), fitness_function=sum_fitness, fitness_history_fname='.__fitness_history__.csv'): # copy the temp file: import shutil extensionless_fname, extension = os.path.splitext(fname) temp_fname = os.path.join(ga_folder(), fitness_history_fname) new_file = extensionless_fname + '__fitness_history.csv' shutil.copy(temp_fname, new_file) print 'fitness history saved to "{}"'.format(new_file) # best_ind = [x for x in ga_engine.bestIndividual()] best_ind = ga_engine.bestIndividual() pars = np.array(best_ind.genomeList) new_file = extensionless_fname + "__parameters.txt" np.savetxt(new_file, pars) print 'best parameters saved to "{}"'.format(new_file) # save the best parameters translated by the fitness function: # if the fitness function can save, do it for the # best parameters: try: new_file = extensionless_fname + "__best" + extension fitness_function(pars, save_in=new_file) print 'best parameters translated by "{}" saved to "{}"'.format( fitness_function, new_file) except: traceback.print_exc()
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 main(argv): genome = G1DList.G1DList(3) genome.setParams(rangemin= 0, rangemax=100) genome.evaluator.set(perfect_weather) ga = GSimpleGA.GSimpleGA(genome) ga.evolve(freq_stats=10) print ga.bestIndividual()
def synthesize(Uplus, Uminus): """Finds a CFG consistent with the input by means of GA Input: a sample, Sample = (Uplus, Uminus) without lambda Output: the parser of an inferred CFG or None""" global posPart, negPart, GTU posPart, negPart = Uplus, Uminus idx = Idx(0) GTU = set() for w in Uplus: GTU.update(primitiveCFG(w, tr(w, idx))) nvars = idx + 1 genome = G1DList.G1DList(nvars) genome.setParams(rangemin=0, rangemax=nvars - 1) genome.evaluator.set(eval_func) ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(400) ga.setCrossoverRate(0.9) ga.setMutationRate(0.05) ga.setPopulationSize(1000) ga.evolve(freq_stats=50) # will show the statistics # every 50th generation (the parameter may be omitted) best_indiv = ga.bestIndividual() Pi = decodeToPi(best_indiv) G = inducedCFG(Pi, GTU) parser = Parser(G) if any(parser.accepts(w) for w in Uminus) \ or not all(parser.accepts(w) for w in Uplus): return None return parser
def evolve_weights(self): genome = G1DList.G1DList(len(self.features)) if self.raw_features: genome.setParams(rangemin=0, rangemax=100.0, gauss_mu=0, gauss_sigma=5.0) genome.evaluator.set(self.eval_func_raw_features) else: genome.setParams(rangemin=0, rangemax=1.0, gauss_mu=0, gauss_sigma=1.0/len(self.features)) genome.evaluator.set(self.eval_func_confidences) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealGaussian) ga = GSimpleGA.GSimpleGA(genome) ga.setElitism(False) ga.setPopulationSize(12) ga.setMinimax(pyevolve.Consts.minimaxType["maximize"]) ga.setGenerations(100) ga.setMutationRate(0.7) ga.evolve(freq_stats=1) path = ospath.join(ospath.dirname(__file__), "evolved_weights/"+str(time.time())+".txt") f = open(path, 'w') f.write(str(ga.bestIndividual())) f.write(str(self.features) + "\n") f.write("atom_type: " + str(self.atom_type) + "\n") f.write("cluster type: " + str(self.cluster_type) + "\n") f.write("num_documents: " + str(self.num_documents) + "\n") f.close() print ga.bestIndividual()
def run_main(): # Genome instance genome = G1DList.G1DList(15) genome.setParams(rangemin=-1, rangemax=1.1) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealRange) # The evaluator function (objective function) genome.evaluator.set(rosenbrock) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.setMinimax(Consts.minimaxType["minimize"]) ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(4000) ga.setCrossoverRate(0.9) ga.setPopulationSize(100) ga.setMutationRate(0.03) ga.evolve(freq_stats=500) # Best individual best = ga.bestIndividual() print "\nBest individual score: %.2f" % (best.score, ) print best
def run_main(): genome = G1DList.G1DList(len(sentence)) #instanciando uma classe do tipo G1DList (representacao do cromossomo 1D List) genome.setParams(rangemin=min(numeric_sentence), #definindo parametros iniciais. rangemax=max(numeric_sentence), bestrawscore=0.00, gauss_mu=1, gauss_sigma=4) #menor codigo numerico, mairo codigo numerico, best score, media, desvio padrao http://pyevolve.sourceforge.net/module_mutators.html?highlight=g1dlistmutatorintegergaussian#Mutators.G1DListMutatorIntegerGaussian genome.initializator.set(Initializators.G1DListInitializatorInteger) #iniciliza funcao de inteiros de G1Dlist genome.mutator.set(Mutators.G1DListMutatorIntegerGaussian) #aplica a mutacao gaussiana onde a media eh 0 e o desvio padrao eh genome.evaluator.set(lambda genome: sum( #chamada para avaliar o genoma [abs(a-b) for a, b in zip(genome, numeric_sentence)] #FITNESS )) ga = GSimpleGA.GSimpleGA(genome) #manda o genoma pro algoritmo genetico # ga.stepCallback.set(evolve_callback) ga.setMinimax(Consts.minimaxType["minimize"]) #seta para minimizar ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) # criterio de parada usando o best score bruto ga.setPopulationSize(60) #tamanho da populacao ga.setMutationRate(0.02) #taxa de mutacao entre 0 e 1 ga.setCrossoverRate(0.9) #taxa de cruzamento entre 0 e 1 ga.setGenerations(5000) #numero maximo de geracoes de evolucao ga.evolve(freq_stats=100) #faz geracoes ate o criterio de termino e exibe as informacoes. best = ga.bestIndividual() #retorna o melhor individuo da populacao print "Best individual score: %.2f" % (best.score,) #printa score do melhor print ''.join(map(chr, best)) #retorna os caracteres correspondentes ao codigo numerico passado
def run_main(): # Genome instance genome = G1DList.G1DList(2) genome.setParams(rangemin=-100.0, rangemax=100.0, bestrawscore=0.0000, rounddecimal=4) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealGaussian) # The evaluator function (objective function) genome.evaluator.set(schafferF6) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.selector.set(Selectors.GRouletteWheel) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setGenerations(8000) ga.setMutationRate(0.05) ga.setPopulationSize(100) ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=250) # Best individual best = ga.bestIndividual() print best print "Best individual score: %.2f" % best.getRawScore()
def main_run(): global cm, coords, WIDTH, HEIGHT coords = [(random.randint(0, WIDTH), random.randint(0, HEIGHT)) for i in xrange(CITIES)] cm = cartesian_matrix(coords) genome = G1DList.G1DList(len(coords)) genome.evaluator.set(lambda chromosome: tour_length(cm, chromosome)) genome.crossover.set(Crossovers.G1DListCrossoverEdge) genome.initializator.set(G1DListTSPInitializator) # 3662.69 ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(200000) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(1.0) ga.setMutationRate(0.02) ga.setPopulationSize(80) # This is to make a video ga.stepCallback.set(evolve_callback) # 21666.49 import psyco psyco.full() ga.evolve(freq_stats=500) best = ga.bestIndividual() if PIL_SUPPORT: write_tour_to_img(coords, best, "tsp_result.png") else: print "No PIL detected, cannot plot the graph !"
def run_main(): # Genome instance setOfAlleles = GAllele.GAlleles() for i in xrange(1000): # You can even add objects instead of strings or # primitive values a = GAllele.GAlleleList(['UP', 'DOWN', 'LEFT', 'RIGHT']) setOfAlleles.add(a) # Genome instance genome = G1DList.G1DList(300) #genome.setParams(rangemin=0, rangemax=10) 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(Initializators.G1DListInitializatorAllele) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.selector.set(Selectors.GRouletteWheel) ga.setGenerations(800) ga.stepCallback.set(evolve_callback) # Do the evolution ga.evolve() # Best individual print ga.bestIndividual()
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 runGAGem5(binary, populationSize=20, generations=20): test_vector_properties = TestVectorProperties() # Set up the fitness function's attributes fitness_function.binary = binary fitness_function.gem5traces = [] fitness_function.vectorProperties = test_vector_properties fitness_function.run = get_next_trace_file_number(binary) # Create the population genome = G1DList.G1DList(test_vector_properties.length) genome.setParams(rangemin=test_vector_properties.lower, \ rangemax=test_vector_properties.upper) genome.evaluator.set(fitness_function) genome.mutator.set(Mutators.G1DListMutatorIntegerRange) # Cannot crossover if there is only a single gene in the chromosone if test_vector_properties.length == 1: genome.crossover.clear() else: genome.crossover.set(Crossovers.G1DListCrossoverTwoPoint) # Set up the engine ga = GSimpleGA.GSimpleGA(genome) ga.setPopulationSize(populationSize) ga.setGenerations(generations) ga.setCrossoverRate(0.9) ga.setMutationRate(0.01) ga.setElitism(True) # Run the GA ga.evolve(freq_stats=1) return fitness_function.gem5traces
def genetic(): genome = G1DList.G1DList(2) genome.evaluator.set(fitness_func) genome.setParams(rangemin=2, rangemax=4) ga = GSimpleGA.GSimpleGA(genome) ga.evolve(freq_stats=10) print ga.bestIndividual()
def run_main(): # Genome instance genome = G1DList.G1DList(20) genome.setParams(rangemin=-5.2, rangemax=5.30, bestrawscore=0.00, rounddecimal=2) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealGaussian) genome.evaluator.set(rastrigin) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setGenerations(3000) ga.setCrossoverRate(0.8) ga.setPopulationSize(100) ga.setMutationRate(0.06) ga.evolve(freq_stats=50) best = ga.bestIndividual() print(best)
def run_main(): # Genome instance genome = G1DList.G1DList(5) genome.setParams(rangemin=-8, rangemax=8, bestrawscore=0.00, rounddecimal=2) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.mutator.set(Mutators.G1DListMutatorRealGaussian) # The evaluator function (objective function) genome.evaluator.set(ackley) # Genetic Algorithm Instance ga = GSimpleGA.GSimpleGA(genome) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setGenerations(1000) ga.setMutationRate(0.04) ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) # Create DB Adapter and set as adapter # sqlite_adapter = DBAdapters.DBSQLite(identify="ackley") # ga.setDBAdapter(sqlite_adapter) # Do the evolution, with stats dump # frequency of 10 generations ga.evolve(freq_stats=50) # Best individual best = ga.bestIndividual() print("\nBest individual score: %.2f" % (best.getRawScore(), )) print(best)
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 = G1DList.G1DList(len(sentence)) genome.setParams(rangemin=min(numeric_sentence), rangemax=max(numeric_sentence), bestrawscore=0.00, gauss_mu=1, gauss_sigma=4) genome.initializator.set(Initializators.G1DListInitializatorInteger) genome.mutator.set(Mutators.G1DListMutatorIntegerGaussian) genome.evaluator.set(lambda genome: sum( [abs(a - b) for a, b in zip(genome, numeric_sentence)])) ga = GSimpleGA.GSimpleGA(genome) #ga.stepCallback.set(evolve_callback) ga.setMinimax(Consts.minimaxType["minimize"]) ga.terminationCriteria.set(GSimpleGA.RawScoreCriteria) ga.setPopulationSize(60) ga.setMutationRate(0.02) ga.setCrossoverRate(0.9) ga.setGenerations(5000) ga.evolve(freq_stats=100) best = ga.bestIndividual() print("Best individual score: %.2f" % (best.score, )) print(''.join(map(chr, best)))
def main_run(): global cm, coords, WIDTH, HEIGHT file_read = 0 while file_read == 0: print("Enter the path of the file which contains the nodes and co-ordinates.") filename = raw_input() # input_file = open("att48.tsp", "r") try: input_file = open(filename, "r") file_read += 1 except IOError: print("There was some problem in opening the file. Please enter a valid file path.") # input_file = open("att48.tsp", "r") input_data = input_file.readlines() # print(input_data) data_len = len(input_data) input_data = input_data[6:data_len] CITIES= len(input_data) input_file.close() coords = [] for line in input_data: line = line.rstrip('\n') # print(line) data_list = line.split(' ') # print(data_list) coords.append((float(data_list[1]) , float(data_list[2]))) cm = cartesian_matrix(coords) genome = G1DList.G1DList(len(coords)) genome.evaluator.set(lambda chromosome: tour_length(cm, chromosome)) genome.crossover.set(Crossovers.G1DListCrossoverEdge) genome.initializator.set(G1DListTSPInitializator) ga = GSimpleGA.GSimpleGA(genome) ga.setGenerations(1000) ga.setMinimax(Consts.minimaxType["minimize"]) ga.setCrossoverRate(1.0) ga.setMutationRate(0.02) ga.setPopulationSize(80) ga.evolve(freq_stats=500) best = ga.bestIndividual() output_file = open("TSP_output.txt", "w") output_file.write("TOUR_SECTION\n") iter_list = best.getInternalList() iter_list.append(iter_list[0]) print("Total length of the tour: " + str(tour_length(cm, best))) for i in range(len(iter_list)): iter_list[i] = iter_list[i] + 1 output_file.write(str(iter_list[i]) + "\n") print("best\n"+str(iter_list)) # print(type(best)) output_file.close() if PIL_SUPPORT: write_tour_to_img(coords, best, "tsp_result.png") else: print "No PIL detected, cannot plot the graph !"
def setUp(self): self.alleles = GAllele.GAlleles() self.alleles.add(MappedAlleleRange(10, 100)) self.alleles.add(MappedAlleleRange(0, 2, real=True)) self.alleles.add(MappedAlleleList([2, 4, 12])) self.alleles.add(MappedAlleleList([-1])) self.genome = G1DList.G1DList(len(self.alleles)) self.genome.setParams(allele=self.alleles, rangemin=-1, rangemax=1)
def getGenome(fitness_function=sum_fitness, parameters_per_individual=160, parameter_bounds=(-1, 1)): genome = G1DList.G1DList(parameters_per_individual) genome.initializator.set(Initializators.G1DListInitializatorReal) genome.evaluator.set(fitness_function) genome.setParams(rangemin=parameter_bounds[0], rangemax=parameter_bounds[1]) return genome
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 setUp(self): alleles = AllelesWithOperators() alleles.add(G2DList.G2DList(3, 3), weight=9) alleles.add(G1DBinaryString.G1DBinaryString(10), weight=10) alleles.add(G1DList.G1DList(1), weight=1) self.genome = G1DList.G1DList(3) self.genome.setParams(allele=alleles) allele_initializer(self.genome) self.target_2d = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.target_bitmap = [0, 1, 0, 0, 1, 1, 0, 1, 1, 0] self.target_1d = [13] for i in range(3): for j in range(3): self.genome[0][i][j] = self.target_2d[i][j] for i in range(len(self.target_bitmap)): self.genome[1][i] = self.target_bitmap[i] self.genome[2][:] = self.target_1d[:]