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()
