def __init__(self, rep_length, popsize, sp, mut, fitfun, maxgen, cross, nr_processes, run_id , path, onlyThebest, runval):
self.nr_processes = nr_processes
self.currentIteration=0
self.fitfun =fitfun
self.maxIterations=maxgen
self.popsize=popsize
self.cars = []
self.fitArray = []
self.onlyTheBest = onlyThebest
if self.onlyTheBest == 0:
for i in range(self.popsize):
self.cars.append(individual.individual(random.uniform(50,150), random.uniform(0,0.1), random.uniform(0,20), random.uniform(0,1), random.uniform(0,100), random.uniform(0,1), random.uniform(0,1), random.uniform(0,70), random.uniform(0,1), random.randint(5000,8000),random.uniform(0,1),random.uniform(50,110),random.uniform(50,110),random.uniform(5,15)))
print len(self.cars)
if self.onlyTheBest == 1:
#total:1339.172; aalborg: 100.808 alpine1: 212.258 alpine2: 143.42 brondehach: 135.83 corkscrew: 120.926 eroad: 95.704 gtrack: 61.342 forza: 156.748 wheel1: 128.67 wheel2: 183.466 parameters: ['154.897575174', '-0.0199', '-0.139884752072', '0.779904990626', '82.8097466274', '0.971351422208', '0.246257782509', '32.9286263315', '0.0215211462875', '5909.19902', '0.829675710924', '78.4693515643', '49.7170137868', '17.9086116398']
#FAEHRT SICHER aber auf manchen strecken ein wenig langsammer
self.cars.append(individual.individual('154.897575174', '-0.0199', '-0.139884752072', '0.779904990626', '82.8097466274', '0.971351422208', '0.246257782509', '32.9286263315', '0.0215211462875', '5909.19902', '0.829675710924', '78.4693515643', '49.7170137868', '17.9086116398'))
#total:1314.005; aalborg: 100.144 alpine1: 202.608 alpine2: 139.396 brondehach: 131.636 corkscrew: 123.965 eroad: 95.432 gtrack: 61.22 forza: 154.07 wheel1: 128.66 wheel2: 176.874 parameters: ['154.897575174', '-0.0199', '-0.0538732272792', '0.779904990626', '82.8097466274', '0.774216279987', '0.246257782509', '32.9286263315', '0.0215211462875', '5909.19902', '0.829675710924', '78.4693515643', '44.6453124081', '17.9086116398']
#SCHNELLER aber unsicherer
#self.cars.append(individual.individual('154.897575174', '-0.0199', '-0.0538732272792', '0.779904990626', '82.8097466274', '0.774216279987', '0.246257782509', '32.9286263315', '0.0215211462875', '5909.19902', '0.829675710924', '78.4693515643', '44.6453124081', '17.9086116398'))
self.tournamentSize=sp
self.crossoverChance = cross
self.debug=0
self.mutationChance = mut
self.runval=runval
def first_generation(self, gen_size, len_behav_seq = 100, seed = None, **kwargs):
'''
Initialize first generation
This function is only used in order to initialize the very first generation!
For the following generations use the "inherit()" function
gen_size: Number of Individuals in Generation
Please specify 'opt_behav_seq' (optimal behavioural sequence):
opt_behav_seq = [---your behav_seq ---]
len_behav_seq (optional): The length of the behavioural sequences
seed (optional): If a seed is given, the run can be reproduced using the exact same seed
'''
# SEEDING
self.__seed = seed
if self.__seed != None:
seed_list1 = generation.__create_seed_list(gen_size * 100, self.__seed)
#Creating a second seed list
seed_list2 = generation.__create_seed_list(gen_size, self.__seed + 1111)
seed_list3 = generation.__create_seed_list(gen_size, self.__seed + 2222)
#Start of the real function
ind_list = []
for i in range(gen_size):
if self.__seed != None:
ind_seed_list = seed_list1[i*100 : (i+1)*100]
ind = individual.individual(seed_list = ind_seed_list)
np.random.seed(seed_list2[i])
else:
ind = individual.individual()
#Initialize genotype
ind.genotype = np.random.uniform(low = 0.0, high = 1.0)
#Initialize behav_seq
if self.__seed != None:
np.random.seed(seed_list3[i])
ind.behav_seq = list(np.random.uniform(low = 0.0, high = 1.0, size = len_behav_seq))
ind_list.append(ind)
self.ind_list = ind_list
self.do_calculations(**kwargs)
self.__create_env_change_ind_life(**kwargs)
self.__simulate_env_change_ind_life(**kwargs)
def initialize(self):
for i in range(self.pop_size):
temp=individual.individual(self.chrom_size)
temp.populate(self.search_space)
# print("Generated chromosomes: ")
# print(temp.getChromosome())
self.chrom_set.append(temp)
def initPopulation(self):
self.lives = []
for i in range(self.lifeCount):
gene = [x for x in range(self.geneLength)]
random.shuffle(gene)
life = individual(gene)
self.lives.append(life)
def restart(self):
dist = None
# Individual
indivi = None
self.w1 = 0.0
#self.idivi_list.sort(key = lambda x:x.fitness)
#sorted(self.idivi_list)
self.idivi_list.sort(key=lambda x: x.fitness, reverse=True)
indivi = self.idivi_list[0].clone()
"""
for i in range(0,len(indivi.geneR)):
print("After self.idivi_list[0].clone() the indivi.geneR["+str(i)+"] is "+str(indivi.geneR[i]))
"""
indivi.set_w1(self.w1)
self.idivi_list.clear()
self.idivi_list.append(indivi)
for i in range(1, self.pop_size):
indivi = individual()
indivi.init_three(self.rule_base, self.data_base, self.w1)
indivi.random_values()
self.idivi_list.append(indivi)
self.evaluate(0)
self.L = self.lini
def initPop(cityList):
population = []
for i in range(POPSIZE):
ind = individual(CHROMSIZE)
ind.initRandom(cityList)
population.append(ind)
return population
def generate_population(number = 100):
assert(number > 0), "Population needs to be greater than 0"
population = {}
for _ in xrange(number):
pop = individual([uniform(1, MAX) for _ in xrange(2)])
population[pop.id] = pop
return population
def init_here(self):
#print("init_here, initial a new indIn clone of individual, copy the self.geneR6 isividual ......")
ind = individual()
ind.init_three(self.rule_base, self.data_base, self.w1)
ind.reset()
self.idivi_list.append(ind)
#print("self.pop_size in init_here for add how many individual into idivi_list is :"+ str(self.pop_size))
for i in range(1, int(self.pop_size)):
#print("in loop initial a new individual ......")
ind = individual()
ind.init_three(self.rule_base, self.data_base, self.w1)
ind.random_values()
#print("going to add a new individual ......")
self.idivi_list.append(ind)
#print(" how many idividuals were added in self.idivi_list : "+ str(len(self.idivi_list)))
self.best_fitness = 0.0
self.nTrials = 0
def init_population(self): for i in range(self.subnum): ind = individual(self.file_name) ind.randomize() ind.get_obj() #每次随机化后就生成目标函数的值 self.update_reference_point(ind) self.dict_sub[i].individual = deepcopy(ind) self.updateEP(ind) self.FunEvals += 1 print "init_population done!"
def generate_individuals(self):
nov_map = novelty_map(self.novelty_map_size)
survives = []
for gene in self.population:
ind = individual(gene,self.excitation_threshold)
yield ind
#exclude fitness:nan
if math.isnan(ind.fitness):
continue
#add survives
gene.fitness = ind.fitness
survives.append(gene)
nov_map.add_node(gene)
self.mutation(self.select_parents(survives, list(nov_map.nodes())))
def newChild(self):
#产生新个体
parent1 = self.getOne()
rate = random.random()
if rate <= self.crossRate:
parent2 = self.getOne()
gene = self.cross(parent1, parent2)
else:
gene = parent1.gene
#突变
rate = random.random()
if rate <= self.mutationRate:
gene = self.mutation(gene)
#根据新的基因返回一个新的对象
return individual(gene)
def __init__(self, ratio, n, seed=None, distance=None):
if distance is None:
distance = 0.1
if seed is None:
seed = Random(10001)
self.length = n
self.ratio = ratio
self.stack = np.empty((n), dtype=object)
self.seed = seed
self.distance = distance
for i in range(n):
if i < ratio * n:
gender = 'male'
else:
gender = 'female'
self.stack[i] = ind.individual(i,
gender,
seed=seed,
distance=distance)
def add_profile(self,
gender,
hotness=None,
threshold=None,
distance=None,
seed=None,
move=True,
move_x=None,
move_y=None):
if distance is None:
distance = self.distance
if seed is None:
seed = self.seed
temp = ind.individual(self.length, gender, hotness, threshold,
distance, seed)
if move:
temp.move(move_x, move_y)
self.stack.append(temp)
self.length = self.length + 1
def load_population(gen):
with open(f'population-gen-{gen}.yaml', 'r') as f:
reload = yaml.safe_load(f)
reload_population = []
for individual_id in reload:
ind = individual()
ind.id = individual_id
ind.genes = reload[individual_id]['genes']
ind.j_fluc = reload[individual_id]['j_fluc']
ind.j_act = reload[individual_id]['j_act']
ind.j_total = reload[individual_id]['j_total']
ind.sensor = reload[individual_id]['sensor']
ind.revolutions = reload[individual_id]['revolutions']
# Needs to be np array not just regular list.
ind.revolutions[0] = np.asarray(ind.revolutions[0])
ind.revolutions[1] = np.asarray(ind.revolutions[1])
ind.revolutions[2] = np.asarray(ind.revolutions[2])
reload_population.append(ind)
return reload_population
convergence = 0
done = False
fitCheck = 0
#mutationRate = uniform(0.051, 0.058)
#popSize = randrange(30,200,2)
#generationLimit = randrange(50,10000)
#Population lists
population = []
offspring = []
# INITIALISE and EVALUATE: Random genes for initial population
for genes in range(popSize):
# INITIALISE
indiv = individual()
indiv.BinGeneCreateInit(chromosomeAmount)
population.append(indiv)
#Best gene initialised
best = population[0]
newBest = population[0]
#REPEAT UNTIL DONE - Main loop
while generation < generationLimit:
#Reset average fitness, increment generation count
avgFitness = 0.0
generation = generation + 1
print('Gen = ', generation)
#1 SELECT parents
def cross_mut(mate_pool,mut_prob,mut_type,g,G,limit,n_genes):
child = individual()
p0 = 0
p1 = 0
counter = 0
while p0 == p1:
p0 = random.choice(mate_pool)
p1 = random.choice(mate_pool)
#loop protection
if counter > limit:
return None
#arithmetic crossover
for motor in range(3):
for key in gene_keys:
bias = random.uniform(0, 1 + offset)
gene = bias * p0.genes[key][motor] + (1-bias) * p1.genes[key][motor]
gene = sat_lim(gene = gene,key = key)
child.genes[key].append(gene)
#mutation
mut_check = random.uniform(0,1)
r = random.uniform(0,1+offset)
tau = random.choice([-1,1])
if mut_check < mut_prob:
if mut_type == 'all':
for motor in range(3):
for key in gene_keys:
mut_gene = child.genes[key][motor] + tau*(u_bound[key] - l_bound[key])*(1-r**(g/G))
if key == 'frequency':
mut_gene = child.genes[key][motor] + tau * (u_bound[key] - 0) * (1 - r ** (g / G))
mut_gene = sat_lim(gene = mut_gene,key = key)
child.genes[key][motor] = mut_gene
if mut_type == 'motor':
motor = random.choice(range(3))
for key in gene_keys:
mut_gene = child.genes[key][motor] + tau * (u_bound[key] - l_bound[key]) * (1 - r ** (g / G))
if key == 'frequency':
mut_gene = child.genes[key][motor] + tau * (u_bound[key] - 0) * (1 - r ** (g / G))
mut_gene = sat_lim(gene=mut_gene, key=key)
child.genes[key][motor] = mut_gene
if mut_type == 'gene':
motor = random.choice(range(3))
key = random.choice(gene_keys)
mut_gene = child.genes[key][motor] + tau * (u_bound[key] - l_bound[key]) * (1 - r ** (g / G))
if key == 'frequency':
mut_gene = child.genes[key][motor] + tau * (u_bound[key] - 0) * (1 - r ** (g / G))
mut_gene = sat_lim(gene=mut_gene, key=key)
child.genes[key][motor] = mut_gene
if mut_type == 'n_genes':
shuffled_motors = list(range(3))
shuffled_keys = gene_keys.copy()
for _ in range(3):
random.shuffle(shuffled_motors)
random.shuffle(shuffled_keys)
mut_counter = 0
while mut_counter <= n_genes:
for motor in shuffled_motors:
for key in shuffled_keys:
mut_counter += 1
mut_gene = child.genes[key][motor] + tau*(u_bound[key] - l_bound[key])*(1-r**(g/G))
if key == 'frequency':
mut_gene = child.genes[key][motor] + tau * (u_bound[key] - 0) * (1 - r ** (g / G))
mut_gene = sat_lim(gene=mut_gene, key=key)
child.genes[key][motor] = mut_gene
if mut_type == 'rand_genes':
shuffled_motors = list(range(3))
shuffled_keys = gene_keys.copy()
for _ in range(3):
random.shuffle(shuffled_motors)
random.shuffle(shuffled_keys)
mut_counter = 0
rand_genes = random.choice(list(range(1,12)))
while mut_counter <= rand_genes:
for motor in shuffled_motors:
for key in shuffled_keys:
mut_counter += 1
mut_gene = child.genes[key][motor] + tau*(u_bound[key] - l_bound[key])*(1-r**(g/G))
if key == 'frequency':
mut_gene = child.genes[key][motor] + tau * (u_bound[key] - 0) * (1 - r ** (g / G))
mut_gene = sat_lim(gene=mut_gene, key=key)
child.genes[key][motor] = mut_gene
return child
def __genetic_inheritance(self, prev_gen, mutation_var = 0.001, selection_dist_genotype = "lin"):
self.__seed = prev_gen.__seed
gen_size = len(prev_gen.ind_list)
prev_ind_list = prev_gen.ind_list
if self.__seed != None:
seed_list4 = generation.__create_seed_list(gen_size, self.__seed + 3333)
#original order of fitnesses of individuals
try:
fit_orig_order = prev_gen.attrs_tolist("fitness")
except AttributeError:
raise AttributeError('''
The individuals of a generation don't have a
'fitness' as an attribute. In order to calculate
it run --generation_object--.do_calculatins()
''')
fit_orig_order = np.array(fit_orig_order)
#create array that would sort fit_orig_order
sort_arr = np.argsort(fit_orig_order)
#invert sort_arr for descending order
sort_arr = sort_arr[::-1]
### inheritance of genotype ###
new_ind_list = []
for i in range(gen_size):
new_ind = individual.individual()
if self.__seed != None:
np.random.seed(seed_list4[i])
if selection_dist_genotype == "lin":
index_sort_arr = np.array(np.random.triangular(0, 0, len(sort_arr)), dtype = int)
elif selection_dist_genotype == "exp":
# Exponential random parameter is used, making it most likely that
# genetic information of fittest individual is inherited
index_sort_arr = np.array(np.random.exponential(scale = len(sort_arr) / 8 ), dtype = int)
#in case calculated index exceeds index of sort_arr, try again:
ct = 0
while index_sort_arr >= (len(sort_arr) - 1) :
print("exp rand par exceeded ", len(sort_arr) )
#!!!!!!LÖSUNG FÜR SEEDS SUCHEN, am besten fetten stack bauen für jedes individuum!!!!!!!
#if ct == 0:
# raise Warning("No Seed used -- run not reproducable")
index_sort_arr = np.array(np.random.exponential(scale = len(sort_arr) / 8), dtype = int)
ct += 1
if ct == 500:
raise RuntimeWarning("Caught up in while loop")
# The index in the sort_arr, that we chose is the index - or number of -individual-
# in the original order that we chose to inherit genotype from (to be the parent)
index_orig_order = sort_arr[index_sort_arr]
parent_ind = prev_ind_list[index_orig_order]
new_ind.gen_genotype(parent_ind, mutation_var)
new_ind_list.append(new_ind)
self.ind_list = new_ind_list
def generate_population(num_individuals, ind_size): generated_pop = list() for _ in xrange(num_individuals): generated_pop.append( individual.individual(ind_size, MINIMIZE, INDEX_RANGE)) return generated_pop
def crossMutateRun(self):
"""Crosses traits from surviving individuals to regenerate population,
then runs the new individuals to evaluate their cost.
"""
# Loop until population has been replenished.
# Extract the number of individuals.
n = len(self.individualsList)
#chooseCount = []
while len(self.individualsList) < self.numInd:
if random.random() < self.probabilities['cross']:
# Since we're crossing over, we won't force a mutation.
forceMutate = False
# Prime loop to select two unique individuals. Loop ensures
# unique individuals are chosen.
_individualsList = [0, 0]
while _individualsList[0] == _individualsList[1]:
# Pick two individuals based on cumulative weights.
_individualsList = random.choices(self.individualsList[0:n],
weights=\
self.rouletteWeights,
k=2)
# Keep track of who created these next individuals.
parents = (_individualsList[0].uid, _individualsList[1].uid)
self.log.debug(('Individuals {} and {} selected for ' +
'crossing').format(parents[0], parents[1]))
# Cross the regulator chromosomes
regChroms = crossChrom(chrom1=_individualsList[0].regChrom,
chrom2=_individualsList[1].regChrom)
self.log.debug('Regulator chromosomes crossed.')
# Cross the capaictor chromosomes
capChroms = crossChrom(chrom1=_individualsList[0].capChrom,
chrom2=_individualsList[1].capChrom)
self.log.debug('Capacitor chromosomes crossed.')
else:
# We're not crossing over, so force mutation.
forceMutate = True
# Draw an individual.
_individualsList = random.choices(self.individualsList[0:n],
weights=self.rouletteWeights,
k=1)
# Track parents
parents = (_individualsList[0].uid, )
self.log.debug(('No crossing, just mutation of individual ' +
'{}'.format(parents[0])))
# Grab the necessary chromosomes, put in a list
regChroms = [_individualsList[0].regChrom]
capChroms = [_individualsList[0].capChrom]
# Track chosen individuals.
"""
for i in _individualsList:
uids = [x[1] for x in chooseCount]
if i.uid in uids:
ind = uids.index(i.uid)
# Increment the occurence count
chooseCount[ind][2] += 1
else:
chooseCount.append([i.fitness, i.uid, 1])
"""
# Possibly mutate individual(s).
if forceMutate or (random.random() < self.probabilities['mutate']):
# Mutate regulator chromosome:
regChroms = mutateChroms(c=regChroms,
prob=self.probabilities['regMutate'])
self.log.debug('Regulator chromosome(s) mutated.')
# Mutate capacitor chromosome:
capChroms = mutateChroms(c=capChroms,
prob=self.probabilities['capMutate'])
self.log.debug('Capacitor chromosome(s) mutated.')
# Create individuals based on new chromosomes, add to list, put
# in queue for processing.
for i in range(len(regChroms)):
# Initialize new individual
uid = self.popMgr.getUID()
ind = individual(
**self.indInputs,
uid=uid,
regChrom=regChroms[i],
capChrom=capChroms[i],
parents=parents,
)
self.log.debug('New individual, {}, initialized'.format(uid))
# Put individual in the list and the queue.
self.individualsList.append(ind)
self.addToModelQueue(individual=ind)
self.log.debug(
('Individual {} put in the model ' + 'queue.').format(uid))
"""
def initializePop(self):
"""Method to initialize the population.
TODO: Make more flexible.
"""
# Create baseline individual.
if self.baseControlFlag is not None:
# Set regFlag and capFlag
if self.baseControlFlag:
# Non-zero case --> volt or volt_var control
regFlag = capFlag = 3
else:
# Manual control, use 'newState'
regFlag = capFlag = 4
# Add a baseline individual with the given control flag
self.individualsList.append(
individual(**self.indInputs,
uid=self.popMgr.getUID(),
regFlag=regFlag,
capFlag=capFlag,
controlFlag=self.baseControlFlag))
# Track the baseline individual's index.
self.baselineIndex = len(self.individualsList) - 1
self.log.debug('Baseline individual created and added to list.')
# Create 'extreme' indivuals - all caps in/out, regs maxed up/down
# Control flag of 0 for manual control
for n in range(len(CAPSTATUS)):
for regFlag in range(2):
ind = individual(**self.indInputs,
uid=self.popMgr.getUID(),
regFlag=regFlag,
capFlag=n,
controlFlag=0)
self.individualsList.append(ind)
self.log.debug("'Extreme' individuals created.")
# Create individuals with biased regulator and capacitor positions
# TODO: Stop hard-coding the number.
for _ in range(4):
ind = individual(**self.indInputs,
uid=self.popMgr.getUID(),
regFlag=2,
capFlag=2,
controlFlag=0)
self.individualsList.append(ind)
self.log.debug("'Biased' individuals created.")
# Randomly create the rest of the individuals.
while len(self.individualsList) < self.numInd:
# Initialize individual.
ind = individual(**self.indInputs,
uid=self.popMgr.getUID(),
regFlag=5,
capFlag=5,
controlFlag=0)
self.individualsList.append(ind)
self.log.debug("Random individuals created.")
self.log.info('Population initialized.')
def step(self):
self.tempArray = [i for i in range(len(self.cars))]
self.getFitnessValues()
for replacer in range (len(self.cars)):
self.numberOfElites = (int((1-self.crossoverChance)*self.popsize))+2
if replacer < self.numberOfElites: ##keep the elites
self.tempArray[replacer] = self.cars[self.returnFittest()]
pass
else:
for i in range(0,self.tournamentSize):##select parents in tournament
self.parent1 = 9999999
self.parent2 = 9999999
self.randomPos = random.randint(0, len(self.fitArray)-1)
while(self.fitArray[self.randomPos] == -1):
#print "-1.. get a new one"
self.randomPos = random.randint(0, len(self.fitArray)-1)
if self.parent1==9999999:
self.parent1=self.randomPos
elif self.fitArray[self.randomPos] < self.fitArray[self.parent1]:
if self.fitArray[self.randomPos] == -1:
pass
else:
self.parent1=self.randomPos
self.randomPos = random.randint(0, len(self.fitArray)-1)
while(self.fitArray[self.randomPos] == -1):
self.randomPos = random.randint(0, len(self.fitArray)-1)
if self.parent2==9999999:
self.parent2=self.randomPos
elif self.fitArray[self.randomPos] < self.fitArray[self.parent2]:
if self.fitArray[self.randomPos] == -1:
pass
else:
self.parent2=self.randomPos
self.tempArray[replacer]=individual.individual(self.cars[self.parent1].values[0],self.cars[self.parent2].values[1], self.cars[self.parent1].values[2], self.cars[self.parent2].values[3], self.cars[self.parent1].values[4], self.cars[self.parent2].values[5], self.cars[self.parent1].values[6], self.cars[self.parent2].values[7],self.cars[self.parent1].values[8],self.cars[self.parent2].values[9],self.cars[self.parent1].values[10],self.cars[self.parent2].values[11],self.cars[self.parent1].values[12], self.cars[self.parent2].values[13] )
for i in range(len(self.cars)):
self.cars[i] = self.tempArray[i]
for i in range(self.numberOfElites, len(self.cars)):
for gene in range(14):
# print "mutating "+str(i)
if (random.uniform(0, 1) <= self.mutationChance):
muval = (self.cars[i].values[gene] * 0.1)+0.1 #random.uniform(-0.1,0.1)
if (random.uniform(0,1) <= 0.5):
muval = muval*-1
self.cars[i].values[gene] = self.cars[i].values[gene] + muval
self.cars[i].parameters[gene] = str(float(self.cars[i].parameters[gene]) + muval)
pass
self.cars[0]=self.cars[self.returnFittest()]
if self.currentIteration == 0:
print "----------------------------------------------"
print "run "+str(self.runval)+" starts here"
print "run: "+str(self.runval)+" generation: "+str(self.currentIteration)+" fittest at: "+str(self.returnFittest())+" its fitness: "+str(self.returnFittestFitness())
print "it's values: "+str(self.returnFittestValues())
print "pop avg fitn: "+str(self.returnAvgFitness())
print "fitnessarray: "+str(self.fitArray)
print "number of invalids: "+str(self.invalid)
print"\n\n"
bashCommand = "killall torcs-bin"
os.system(bashCommand)
print "killed old torcs processes"
f = open("debugline_wheel2_aal_forza_eroad_street_alpine1.csv","a")
f.write("run: "+str(self.runval)+" generation: "+str(self.currentIteration)+" fittest at: "+str(self.returnFittest())+" its fitness: "+str(self.returnFittestFitness())+"\n")
f.close
f = open("june14_aal_wheel2_aal_forza_eroad_street_alpine1.csv","a") #opens file with name of "test.txt"
if self.currentIteration == 0:
f.write(("\n\n\n\n"))
f.write(("run "+str(self.runval)+" starts here\n"))
f.write("generation; "+str(self.currentIteration)+"; ")
f.write("it's values; "+str(self.returnFittestValues())+"; number of invalids;"+str(self.invalid)+" ; ")
f.write("fitnessarray; "+str(self.fitArray)+"; ")
f.write("pop avg fitn; "+str(self.returnAvgFitness())+"; ")
f.write("fittest at; "+str(self.returnFittest())+"; its fitness; "+str(self.returnFittestFitness())+";\n ")
if self.currentIteration >= self.maxIterations:
f.write(("the end:\n\n\n\n\n"))
f.close
self.currentIteration=self.currentIteration+1
if self.currentIteration >= self.maxIterations:
self.stop_reached = True
def genesis(size):
population = [individual() for _ in range(size)]
population = genes(population = population)
return population
def main():
global CHROMSIZE
filename = sys.argv[1]
seed = sys.argv[2]
saveFile = "outfile" + seed
outData = []
#cityList = openFile('tsps/burma14.tsp')
cityList = openFile(filename)
CHROMSIZE = len(cityList)
random.seed(seed)
# create initial population with random strings
pop = initPop(cityList)
# get fitnesses for population
evaluate(pop)
# test print
# for ind in pop:
# print ind.fitness
# reproduce, double population via random selection and etc, for each generation
for i in range(GENERATIONS):
#print "Gen:", i
#crossover double pop
for j in range(LAMBDA / 2):
parent1 = getRandomIndividual(pop)
parent2 = getRandomIndividual(pop)
child1 = individual(CHROMSIZE)
child2 = individual(CHROMSIZE)
child1.chrom, child2.chrom = crossover(parent1.chrom,
parent2.chrom)
# add new children to population
pop.append(child1)
pop.append(child2)
# eval new members of population
evaluate(pop)
# sort pop in place based on lowest distance (counts as highest fitness)
pop.sort(key=lambda individual: individual.fitness)
# print "more before cull"
# for ind in pop:
# print ind.fitness
# remove excess population
pop[POPSIZE:] = []
# print "aftercull"
# for ind in pop:
# print ind.fitness
# append new generation info to out data
genInfo = [i, minDistance(pop), avgDistance(pop), maxDistance(pop)]
if i % 50 == 0:
print genInfo
outData.append(genInfo)
pickle.dump(outData, open(saveFile, 'w'))
lives1 -= 1
if f == [0, 0]:
if lives1 == 0:
f[0] = -2
f[1] = 1
return f
elif lives2 == 0:
f[1] = 1
f[0] = -2
return f
return f
pop = [individual() for i in range(150)] #creates a bunch of blank individuals
fitnesses = [0] * 150
global innoNum
for indi in pop:
for i in range(10):
innoNum = indi.mutateStructure(150, innoNum)
#store each of the different species
specs = []
for i in range(len(pop)):
for spec in specs:
if delta(pop[i], pop[spec[0]]) < dt:
spec.append(i)
def init_reference_point(self): ind = individual(self.file_name) ind.randomize() ind.get_obj() self.update_reference_point(ind) print "init_reference_point done!"
