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[:]
