for i in tmp_elite:
ELITES.add(i.tag)
new_population = P.map(functionalize_write_file_and_test_fitness_full_model, tmp_elite)
for i in done_elite:
new_population.append(i)
else:
new_population = population[:ELITE]
##########OK, NOW WE ARE DONE WITH ELITES, THEY ARE SAVED FOR NEXT GENERATION, NOW WE NEED TO FILL OUT REST OF POP#####
#########WHICH WE DO BY RECOMBINING AND MUTATING LAST GENERATION, ALL BASED ON PAST PERFORMANCE (I.E. OUR RANK BASED WEIGHTS)
auto_pop_size = NCPUs + ELITE
# print [i.tag for i in population]
# print memo
# print NCPUs, len([1 for i in population if i.tag in memo])
# print range(ELITE, auto_pop_size)
for i in range(ELITE, auto_pop_size):
c1 = weighted_sampler(weight_dict) # SELECT A ORDER BASED ON WEIGHTS, THIS IS PARENT #1
c2 = c1
while c2 == c1:
c2 = weighted_sampler(weight_dict) # SELECT A SECOND ORDER, MAKING SURE IT'S DIFFERENT FROM THE FIRST
# c1 and c2 are the 2 indivduals to be recombined
cnew = swap_mutation(population[c1], memo, {}) # first mutate c1. could do c2 too, but I didn't for now.
cnew = recombination(cnew, population[c2], memo, {}) # NOW RECOMBINE
new_population.append(cnew) # add this onto the next generation
###########FINALLY A LITTLE BOOK KEEPING TO CLEAR OUT DUPLICATE CONTIG ORDERS, WHICH ARE A WASTE OF CYCLES#################
seen = []
tmp_pop = []
for (
i
) in (
new_population
): # occasionally identical orders get in, this removes duplicates and fills in with a new random order
for i in tmp_elite: ELITES.add(i.tag)
new_population = P.map(functionalize_write_file_and_test_fitness_full_model, tmp_elite)
for i in done_elite: new_population.append(i)
print 'recalc needed'
else:
new_population = population[:ELITE]
print time.time() - start, '7 done with recalc as needed'
##########OK, NOW WE ARE DONE WITH ELITES, THEY ARE SAVED FOR NEXT GENERATION, NOW WE NEED TO FILL OUT REST OF POP#####
#########WHICH WE DO BY RECOMBINING AND MUTATING LAST GENERATION, ALL BASED ON PAST PERFORMANCE (I.E. OUR RANK BASED WEIGHTS)
auto_pop_size = NCPUs+ELITE
#print [i.tag for i in population]
#print memo
#print NCPUs, len([1 for i in population if i.tag in memo])
#print range(ELITE, auto_pop_size)
for i in range(ELITE, auto_pop_size):
c1 = weighted_sampler(weight_dict)#SELECT A ORDER BASED ON WEIGHTS, THIS IS PARENT #1
c2 = c1
while c2 == c1:
c2 = weighted_sampler(weight_dict) #SELECT A SECOND ORDER, MAKING SURE IT'S DIFFERENT FROM THE FIRST
#c1 and c2 are the 2 indivduals to be recombined
cnew = swap_mutation(population[c1], memo, {})# first mutate c1. could do c2 too, but I didn't for now.
cnew = recombination(cnew, population[c2], memo, {})#NOW RECOMBINE
new_population.append(cnew)#add this onto the next generation
print time.time() - start, '8 recomb and fitness'
###########FINALLY A LITTLE BOOK KEEPING TO CLEAR OUT DUPLICATE CONTIG ORDERS, WHICH ARE A WASTE OF CYCLES#################
seen = []
tmp_pop = []
for i in new_population: #occasionally identical orders get in, this removes duplicates and fills in with a new random order
if i.tag not in seen:
seen.append(i.tag)
tmp_pop.append(i)
for i in range(1, POP_SIZE): #shuffle all but the first one, leave that at whatever is in the file (prob. v2 genome order)
population[i].shuffle() #randomize
#print [i.tag for i in population]
start = time.time()
for gen in xrange(NGEN):
for i in range(POP_SIZE):
print "generation="+str(gen+1)+';', 'individual='+str(i+1)+';', ' elapsed time (sec):', time.time()-start
population[i].write_file_and_test_fitness()
population.sort(key = lambda s: s.Fitness*-1)
weights = list(reversed(range(1, len(population)+1)))
weight_dict = {i:weights[i] for i in range(len(population))} #using ranked based selection (see :http://www.obitko.com/tutorials/genetic-algorithms/selection.php)
new_population = population[:ELITE]#save the elites
for i in range(ELITE, POP_SIZE):
c1 = weighted_sampler(weight_dict)
c2 = c1
while c2 == c1:
c2 = weighted_sampler(weight_dict)
#c1 and c2 are the 2 indivduals to be recombined
cnew = swap_mutation(population[c1])# first mutate c1. could do c2 too, but I didn't for now.
cnew = recombination(cnew, population[c2])
new_population.append(cnew)#add this onto the next generation
seen = []
tmp_pop = []
for i in new_population: #occasionally identical orders get in, this removes duplicates and fills in with a new random order
if i.tag not in seen:
seen.append(i.tag)
tmp_pop.append(i)
else:
cnew = ContigOrder(chrom_list, chrom_dict, scaff_lookup)
update_subset_memo(i.chrom_list, i.Rates)
memo[i.tag] = [i.Fitness, i.Rates]
weights = list(reversed(range(1, len(population)+1)))
weight_dict = {i:weights[i] for i in range(len(population))} #using ranked based selection (see :http://www.obitko.com/tutorials/genetic-algorithms/selection.php)
# tmp_elite, done_elite = [], []
# for i in population[:ELITE]:
# if i.tag not in ELITES: tmp_elite.append(i)
# else: done_elite.append(i)
# if tmp_elite:
# for i in tmp_elite: ELITES.add(i.tag)
# new_population = P.map(functionalize_write_file_and_test_fitness_full_model, tmp_elite)
# for i in done_elite: new_population.append(i)
# else:
new_population = population[:ELITE]
for i in range(ELITE, POP_SIZE):
c1 = weighted_sampler(weight_dict)
c2 = c1
while c2 == c1:
c2 = weighted_sampler(weight_dict)
#c1 and c2 are the 2 indivduals to be recombined
cnew = swap_mutation(population[c1], memo, subset_memo)# first mutate c1. could do c2 too, but I didn't for now.
cnew = recombination(cnew, population[c2], memo, subset_memo)
new_population.append(cnew)#add this onto the next generation
seen = []
tmp_pop = []
for i in new_population: #occasionally identical orders get in, this removes duplicates and fills in with a new random order
if i.tag not in seen:
seen.append(i.tag)
tmp_pop.append(i)
else:
cnew = ContigOrder(chrom_list, chrom_dict, scaff_lookup, memo, subset_memo)