def search_loop():
"""
This is a standard search process for an evolutionary algorithm. Loop over
a given number of generations.
:return: The final population after the evolutionary process has run for
the specified number of generations.
"""
if params['MULTICORE']:
# initialize pool once, if mutlicore is enabled
params['POOL'] = Pool(processes=params['CORES'], initializer=pool_init,
initargs=(params,)) # , maxtasksperchild=1)
# Initialise population
individuals = initialisation(params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Traditional GE
for generation in range(1, (params['GENERATIONS']+1)):
stats['gen'] = generation
# New generation
individuals = params['STEP'](individuals)
if params['MULTICORE']:
# Close the workers pool (otherwise they'll live on forever).
params['POOL'].close()
return individuals
def search_loop():
"""
This is a standard search process for an evolutionary algorithm. Loop over
a given number of generations.
:return: The final population after the evolutionary process has run for
the specified number of generations.
"""
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Traditional GE
for generation in range(1, (params['GENERATIONS'] + 1)):
stats['gen'] = generation
# New generation
individuals = params['STEP'](individuals)
# Generate statistics for run so far
get_stats(individuals)
return individuals
def act(self):
# Process the information if the agent has sense nearby agents
if self.agents_found:
# Combine the original individual and individuals found by interacting with nearby agents to form
# a population
individuals = self.individual + self.nearby_agents
# Find out parents from the population
parents = selection(individuals)
# Crossover parents and add to the new population.
cross_pop = crossover(parents)
# Mutate the new population.
new_pop = mutation(cross_pop)
# Evaluate the fitness of the new population.
new_pop = evaluate_fitness(new_pop)
# Replace the old population with the new population.
individuals = replacement(new_pop, individuals)
# Generate statistics for run so far
get_stats(individuals)
# Sort the individuals list
individuals.sort(reverse=True)
# Get the higest performing individual from the sorted population
self.new_individual = individuals[0]
def step(individuals):
"""
Runs a single generation of the evolutionary algorithm process:
Selection
Variation
Evaluation
Replacement
:param individuals: The current generation, upon which a single
evolutionary generation will be imposed.
:return: The next generation of the population.
"""
# Select parents from the original population.
parents = selection(individuals)
# Crossover parents and add to the new population.
cross_pop = crossover(parents)
# Mutate the new population.
new_pop = mutation(cross_pop)
# Evaluate the fitness of the new population.
new_pop = evaluate_fitness(new_pop)
# Replace the old population with the new population.
individuals = replacement(new_pop, individuals)
# Generate statistics for run so far
get_stats(individuals)
return individuals
def step(individuals):
"""
Runs a single generation of the evolutionary algorithm process:
Selection
Variation
Evaluation
Replacement
:param individuals: The current generation, upon which a single
evolutionary generation will be imposed.
:return: The next generation of the population.
"""
# Select parents from the original population.
parents = selection(individuals)
# Crossover parents and add to the new population.
cross_pop = crossover(parents)
# Mutate the new population.
new_pop = mutation(cross_pop)
# Evaluate the fitness of the new population.
new_pop = evaluate_fitness(new_pop)
# Replace the old population with the new population.
individuals = replacement(new_pop, individuals)
# Generate statistics for run so far
get_stats(individuals)
return individuals
def act(self):
# Process the information if the agent has sense nearby agents
if self.agents_found:
# Combine the original individual and individuals found by interacting with nearby agents to form
# a population
individuals = self.individual + self.nearby_agents
# Find out parents from the population
parents = selection(individuals)
# Crossover parents and add to the new population.
cross_pop = crossover(parents)
# Mutate the new population.
new_pop = mutation(cross_pop)
# Evaluate the fitness of the new population.
new_pop = evaluate_fitness(new_pop)
# Replace the old population with the new population.
individuals = replacement(new_pop, individuals)
# Generate statistics for run so far
get_stats(individuals)
# Sort the individuals list
individuals.sort(reverse=True)
# Get the highest performing individual from the sorted population
self.new_individual = individuals[0]
def mane():
""" Run program """
# Run evolution
individuals = params['SEARCH_LOOP']()
# Print final review
get_stats(individuals, end=True)
def mane():
""" Run program """
# Run evolution
individuals = params['SEARCH_LOOP']()
# Print final review
get_stats(individuals, end=True)
def mane():
""" Run program """
# Run evolution
individuals = params['SEARCH_LOOP']()
# Print final review
get_stats(individuals, end=True)
# Returns only needed if running experiment manager
return params['TIME_STAMP'], stats['best_ever'].fitness
def mane():
""" Run program """
# Run evolution
individuals = params['SEARCH_LOOP']()
# Print individuals in commandline
print('-*10')
print('-*10')
# Print final review
get_stats(individuals, end=True)
def search_loop():
"""
This is a standard search process for an evolutionary algorithm. Loop over
a given number of generations.
:return: The final population after the evolutionary process has run for
the specified number of generations.
"""
logf = open(params['FILE_PATH'] + "/log.csv", 'w') #190312: log
set_M() #190307: our mod for learning multiplier
if params['MULTICORE']:
# initialize pool once, if mutlicore is enabled
params['POOL'] = Pool(processes=params['CORES'],
initializer=pool_init,
initargs=(params, )) # , maxtasksperchild=1)
# Initialise population
individuals = initialisation(params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
write_log(logf, 0, params['M'], individuals) #190312: log
#write_best(0, params['M'], individuals)
# Traditional GE
for generation in range(1, (params['GENERATIONS'] + 1)):
stats['gen'] = generation
update_M(generation,
individuals) # 190307: our mod for learning multiplier
# New generation
individuals = params['STEP'](individuals)
write_log(logf, generation, params['M'], individuals) #190312: log
#write_best(generation, params['M'], individuals)
print("generation ", generation, "/", params['GENERATIONS'],
" finished at ", datetime.datetime.now()) # 190313: timestamp
if params['MULTICORE']:
# Close the workers pool (otherwise they'll live on forever).
params['POOL'].close()
logf.close()
return individuals
def mane():
""" Run program """
try:
# Run evolution
individuals = params['SEARCH_LOOP']()
# Print final review
get_stats(individuals, end=True)
except Exception as err:
import datetime
print("Error occured at ", datetime.datetime.now(), flush=True)
print(err, flush=True)
raise err
def search_loop():
"""
This is a standard search process for an evolutionary algorithm. Loop over
a given number of generations.
:return: The final population after the evolutionary process has run for
the specified number of generations.
"""
if params['MULTICORE']:
# initialize pool once, if mutlicore is enabled
params['POOL'] = ThreadPool(
processes=params['CORES'],
initializer=pool_init,
initargs=(params, )) # , maxtasksperchild=1)
Logger.log("Generation 0 starts. Initializing...")
# Initialise population
individuals = initialisation(params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Cleanup after evaluation
if 'cleanup' in dir(params['FITNESS_FUNCTION']):
params['FITNESS_FUNCTION'].cleanup(individuals)
# Traditional GE
for generation in range(1, (params['GENERATIONS'] + 1)):
stats['gen'] = generation
params['CURRENT_EVALUATION'] = 0
params['CURRENT_GENERATION'] = generation
Logger.log("Generation {0} starts...".format(generation))
# New generation
individuals = params['STEP'](individuals)
# Cleanup after evaluation
if 'cleanup' in dir(params['FITNESS_FUNCTION']):
params['FITNESS_FUNCTION'].cleanup(individuals)
Logger.close_all()
if params['MULTICORE']:
# Close the workers pool (otherwise they'll live on forever).
params['POOL'].close()
return individuals
def get_info_by_domain(domain="test"):
print('>>>>>>>>>>>>>', domain)
session = vk.AuthSession(**crd)
api_obj = vk.API(session)
posts = get_json_by_id(api_obj, domain=domain, limit=5000)
stats = get_stats(posts)
rsp = api_obj.wall.get(domain=domain, extended=1)
group = rsp['groups'][0]
print('>>', group)
name = group['name']
link = group['screen_name']
img_link = group['photo_big']
return stats, name, link, img_link
def mane():
""" Run program """
# Set Fitness Funtion
params['FITNESS_FUNCTION'] = set_fitness_function(params['PROBLEM'],
params['ALTERNATE'])
# Set Grammar File
params['BNF_GRAMMAR'] = grammar.Grammar(params['GRAMMAR_FILE'])
# Run evolution
individuals = search_loop.search_loop_wheel()
# Print final review
get_stats(individuals, end=True)
# Returns only needed if running experiment manager
return params['TIME_STAMP'], stats['best_ever'].fitness
def search_loop():
"""Loop over max generations"""
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness.evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Traditional GE
for generation in range(1, (params['GENERATIONS'] + 1)):
stats['gen'] = generation
# New generation
individuals = step.step(individuals)
# Generate statistics for run so far
get_stats(individuals)
return individuals
def search_loop_complete_evals():
"""Loop over total evaluations"""
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness.evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Runs for a specified number of evaluations
while len(cache) < (params['GENERATIONS'] * params['POPULATION_SIZE']):
stats['gen'] += 1
# New generation
individuals = step.step(individuals)
# Generate statistics for run so far
get_stats(individuals)
return individuals
def search_loop():
"""
This is a standard search process for an evolutionary algorithm. Loop over
a given number of generations.
:return: The final population after the evolutionary process has run for
the specified number of generations.
"""
print(params['INITIALISATION'], params['POPULATION_SIZE']) # Added by me as a debug - REMOVE
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Traditional GE
for generation in range(1, (params['GENERATIONS']+1)):
stats['gen'] = generation
# New generation
individuals = params['STEP'](individuals)
#ROISIN: To save phenotype of best individual
run_no = int(params["EXTRA_PARAMETERS"])
print("RUN_NO: ", run_no)
best=max(individuals)
print("Best: ", best)
ind=best.phenotype
length = len(ind)
i = 0
# Wrie best to file and play with midi
instruments = ["kick", "hh", "hhOp", "snH", "Sin1", "Sin2"]
bestfile = open("../results/ChucK/" + instruments[run_no] + ".ck", 'w')
""" Separate individaul into lines and add to file"""
while i < length:
# print i
try:
end_line = ind.index(";")
# print "ind: %s end: %d, i: %d"%(ind, end_line, i)
line = ind[: end_line + 1]
try:
if line[0] == "L":
bestfile.write("while (true) \n { \n")
line = line[1:]
except IndexError:
pass
bestfile.write(str(line))
bestfile.write("\n")
ind = ind[end_line + 1:]
except ValueError:
pass
i += end_line
bestfile.write("}")
bestfile.close()
return individuals
def LAHC_search_loop():
"""
Search loop for Late Acceptance Hill Climbing.
This is the LAHC pseudo-code from Bykov and Burke.
Produce an initial solution s
Calculate initial cost function C(s)
Specify Lfa
For all k in {0...Lfa-1} f_k := C(s)
First iteration I=0;
Do until a chosen stopping condition
Construct a candidate solution s*
Calculate its cost function C(s*)
v := I mod Lfa
If C(s*)<=fv or C(s*)<=C(s)
Then accept the candidate (s:=s*)
Else reject the candidate (s:=s)
Insert the current cost into the fitness array fv:=C(s)
Increment the iteration number I:=I+1
:return: The final population.
"""
maximise = params['FITNESS_FUNCTION'].maximise
max_its = params['POPULATION_SIZE'] * params['GENERATIONS']
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
Lfa = params['HILL_CLIMBING_HISTORY']
s = stats['best_ever']
Cs = s.fitness
f = Cs * np.ones(Lfa) # history
I = len(individuals)
for generation in range(1, (params['GENERATIONS'] + 1)):
this_gen = []
# even though there is no population, we will take account of
# the pop size parameter: ie we'll save stats after every
# "generation"
for j in range(params['POPULATION_SIZE']):
this_gen.append(s) # collect this "generation"
s_ = params['MUTATION'](s) # mutate s to get candidate s*
if not s_.invalid:
s_.evaluate()
Cs_ = s.fitness
v = I % Lfa
# ugly
if ((maximise and (Cs_ >= f[v] or Cs_ >= Cs))
or (not maximise and (Cs_ <= f[v] or Cs_ <= Cs))):
# accept the candidate
s = s_
Cs = Cs_
else:
pass # reject the candidate
f[v] = Cs
I += 1
# break from inner and outer if needed
if I >= max_its:
break
# but get this get stats first
stats['gen'] = generation
get_stats(this_gen)
if I >= max_its:
break
return individuals
def SCHC_search_loop():
"""
Search Loop for Step-Counting Hill-Climbing.
This is the SCHC pseudo-code from Bykov and Petrovic.
Produce an initial solution s
Calculate an initial cost function C(s)
Initial cost bound Bc := C(s)
Initial counter nc := 0
Specify Lc
Do until a chosen stopping condition
Construct a candidate solution s*
Calculate the candidate cost function C(s*)
If C(s*) < Bc or C(s*) <= C(s)
Then accept the candidate s := s*
Else reject the candidate s := s
Increment the counter nc := nc + 1
If nc >= Lc
Then update the bound Bc := C(s)
reset the counter nc := 0
Two alternative counting methods (start at the first If):
SCHC-acp counts only accepted moves:
If C(s*) < Bc or C(s*) <= C(s)
Then accept the candidate s := s*
increment the counter nc := nc + 1
Else reject the candidate s := s
If nc >= Lc
Then update the bound Bc := C(s)
reset the counter nc := 0
SCHC-imp counts only improving moves:
If C(s*) < C(s)
Then increment the counter nc := nc + 1
If C(s*) < Bc or C(s*) <= C(s)
Then accept the candidate s := s*
Else reject the candidate s := s
If nc >= Lc
Then update the bound Bc := C(s)
reset the counter nc := 0
:return: The final population.
"""
maximise = params['FITNESS_FUNCTION'].maximise
max_its = params['POPULATION_SIZE'] * params['GENERATIONS']
count_method = "all" # TODO
accept_method = "bykov" # TODO
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
Lc = params['HILL_CLIMBING_HISTORY']
s = stats['best_ever']
Cs = s.fitness
Bc = Cs # initial cost bound
nc = 0
I = len(individuals)
for generation in range(1, (params['GENERATIONS'] + 1)):
this_gen = []
# even though there is no population, we will take account of
# the pop size parameter: ie we'll save stats after every
# "generation"
for j in range(params['POPULATION_SIZE']):
this_gen.append(s) # collect this "generation"
s_ = params['MUTATION'](s) # mutate s to get candidate s*
if not s_.invalid:
s_.evaluate()
Cs_ = s.fitness
# count
if count_method == "all": # we count all iterations (moves)
nc += 1 # increment the counter
elif count_method == "acp": # we count accepted moves only
if ((maximise and (Cs_ > Bc or Cs_ >= Cs))
or ((not maximise) and (Cs_ < Bc or Cs_ <= Cs))):
nc += 1 # increment the counter
elif count_method == "imp": # we count improving moves only
if ((maximise and Cs_ > Cs) or ((not maximise) and Cs_ < Cs)):
nc += 1 # increment the counter
else:
raise ValueError("Unknown count method " + count_method)
# accept
if accept_method == "bykov":
# standard accept method
if ((maximise and (Cs_ > Bc or Cs_ >= Cs))
or ((not maximise) and (Cs_ < Bc or Cs_ <= Cs))):
s = s_ # accept the candidate
Cs = Cs_
else:
pass # reject the candidate
elif accept_method == "nicolau":
# simpler alternative suggested by Nicolau, unpublished
if ((maximise and Cs_ >= Bc)
or ((not maximise) and (Cs_ <= Bc))):
s = s_ # accept the candidate
Cs = Cs_
else:
pass # reject the candidate
else:
raise ValueError("Unknown accept method " + accept_method)
if nc >= Lc:
Bc = Cs # update the bound
nc = 0 # reset the counter
I += 1
# break from inner and outer if needed
if I >= max_its:
break
# but get this gen stats first
stats['gen'] = generation
get_stats(this_gen)
if I >= max_its:
break
return individuals
def search_dynamic_loop():
"""Loop over max generations in a dynamic fitness environment"""
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness.evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# if 'PROBLEM' == "moving_point"
# display the population & the target
if params['PROBLEM'] in ("moving_point", "moving_point_vision",
"moving_point_step"):
display_3D_population(individuals, 0)
display_3D_plotly_population(individuals, 0)
elif params['PROBLEM'] == "moving_point_spiral":
display_3D_population(individuals, 0,
'DYNAMIC_ENVIRONMENT_TARGET_SPIRAL')
display_3D_plotly_population(individuals, 0)
# plot.ly dashboard
elif params['PROBLEM'] in ("moving_point_dual", "new_problem_here"):
display_3D_population_dual_target(individuals, 0)
# Traditional GE
for generation in range(1, (params['GENERATIONS'] + 1)):
stats['gen'] = generation
# New generation
individuals = step.step(individuals)
# Do we change the fitness environment?
if generation % params['DYNAMIC_ENVIRONMENT_PERIOD'] == 0:
print("----+CHANGE FITNESS TARGET+----")
if params['PROBLEM'] == "moving_point":
move_target()
print("gen: ", generation, "\t target: ",
params['DYNAMIC_ENVIRONMENT_TARGET'])
elif params['PROBLEM'] == "moving_point_vision":
move_target_vision_avoid(individuals)
print("gen: ", generation, "\t target: ",
params['DYNAMIC_ENVIRONMENT_TARGET'])
elif params['PROBLEM'] == "moving_point_step":
move_target_step(generation, 'DYNAMIC_ENVIRONMENT_TARGET')
print("gen: ", generation, "\t target: ",
params['DYNAMIC_ENVIRONMENT_TARGET'])
elif params['PROBLEM'] == "moving_point_spiral":
move_target_spiral(generation,
'DYNAMIC_ENVIRONMENT_TARGET_SPIRAL')
print("gen: ", generation, "\t target: ",
params['DYNAMIC_ENVIRONMENT_TARGET_SPIRAL'])
elif params['PROBLEM'] == "moving_point_dual":
move_target_vision_avoid_alt(individuals,
'DYNAMIC_ENVIRONMENT_TARGET',
'MP_DESTINATION_INDEX')
move_target_vision_avoid_alt(individuals,
'DYNAMIC_ENVIRONMENT_TARGET_ALT',
'MP_DESTINATION_INDEX_ALT')
print("gen: ", generation, "\t target: ",
params['DYNAMIC_ENVIRONMENT_TARGET'],
params['DYNAMIC_ENVIRONMENT_TARGET_ALT'])
elif params['PROBLEM'] == "moving_point_realworld":
move_target_realworldmapping()
print("gen: ", generation, "\t target: ",
params['DYNAMIC_ENVIRONMENT_TARGET'])
# Re-evaluate the entire population with this new fitness target
individuals = evaluate_fitness.evaluate_fitness(individuals)
# Reset the population level statistics
#get_stats(individuals) # this also generates an additional entry/gen in the reports e.g.,stats.csv
# Generate statistics for run so far
get_stats(individuals)
# if 'PROBLEM' == "moving_point"
# display the population & the target
if params['PROBLEM'] in ("moving_point", "moving_point_vision",
"moving_point_step", "moving_point_realworld",
"new_problem_here"):
display_3D_population(individuals, generation)
display_3D_plotly_population(individuals, generation)
elif params['PROBLEM'] == "moving_point_spiral":
display_3D_population(individuals, generation,
'DYNAMIC_ENVIRONMENT_TARGET_SPIRAL')
elif params['PROBLEM'] in ("moving_point_dual", "new_problem_here"):
display_3D_population_dual_target(individuals, generation)
return individuals
def LAHC_search_loop():
"""
Search loop for Late Acceptance Hill Climbing.
This is the LAHC pseudo-code from Burke and Bykov:
Produce an initial solution best
Calculate initial cost function C(best)
Specify Lfa
For all k in {0...Lfa-1} f_k := C(best)
First iteration iters=0;
Do until a chosen stopping condition
Construct a candidate solution best*
Calculate its cost function C(best*)
idx := iters mod Lfa
If C(best*)<=f_idx or C(best*)<=C(best)
Then accept the candidate (best:=best*)
Else reject the candidate (best:=best)
Insert the current cost into the fitness array f_idx:=C(best)
Increment the iteration number iters:=iters+1
:return: The final population.
"""
max_its = params['POPULATION_SIZE'] * params['GENERATIONS']
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Find the best individual so far.
best = trackers.best_ever
# Set history.
Lfa = params['HILL_CLIMBING_HISTORY']
history = [best for _ in range(Lfa)]
# iters is the number of individuals examined so far.
iters = len(individuals)
for generation in range(1, (params['GENERATIONS']+1)):
this_gen = []
# even though there is no population, we will take account of
# the pop size parameter: ie we'll save stats after every
# "generation"
for j in range(params['POPULATION_SIZE']):
this_gen.append(best) # collect this "generation"
# Mutate the best to get the candidate best
candidate_best = params['MUTATION'](best)
if not candidate_best.invalid:
candidate_best.evaluate()
# Find the index of the relevant individual from the late
# acceptance history.
idx = iters % Lfa
if candidate_best >= history[idx]:
best = candidate_best # Accept the candidate
else:
pass # reject the candidate
# Set the new best into the history.
history[idx] = best
# Increment evaluation counter.
iters += 1
if iters >= max_its:
# We have completed the total number of iterations.
break
# Get stats for this "generation".
stats['gen'] = generation
get_stats(this_gen)
if iters >= max_its:
# We have completed the total number of iterations.
break
return individuals
def SCHC_search_loop():
"""
Search Loop for Step-Counting Hill-Climbing.
This is the SCHC pseudo-code from Bykov and Petrovic.
Produce an initial solution best
Calculate an initial cost function C(best)
Initial cost bound cost_bound := C(best)
Initial counter counter := 0
Specify history
Do until a chosen stopping condition
Construct a candidate solution best*
Calculate the candidate cost function C(best*)
If C(best*) < cost_bound or C(best*) <= C(best)
Then accept the candidate best := best*
Else reject the candidate best := best
Increment the counter counter := counter + 1
If counter >= history
Then update the bound cost_bound := C(best)
reset the counter counter := 0
Two alternative counting methods (start at the first If):
SCHC-acp counts only accepted moves:
If C(best*) < cost_bound or C(best*) <= C(best)
Then accept the candidate best := best*
increment the counter counter := counter + 1
Else reject the candidate best := best
If counter >= history
Then update the bound cost_bound := C(best)
reset the counter counter := 0
SCHC-imp counts only improving moves:
If C(best*) < C(best)
Then increment the counter counter := counter + 1
If C(best*) < cost_bound or C(best*) <= C(best)
Then accept the candidate best := best*
Else reject the candidate best := best
If counter >= history
Then update the bound cost_bound := C(best)
reset the counter counter := 0
:return: The final population.
"""
# Calculate maximum number of evaluation iterations.
max_its = params['POPULATION_SIZE'] * params['GENERATIONS']
count_method = params['SCHC_COUNT_METHOD']
# Initialise population
individuals = params['INITIALISATION'](params['POPULATION_SIZE'])
# Evaluate initial population
individuals = evaluate_fitness(individuals)
# Generate statistics for run so far
get_stats(individuals)
# Set best individual and initial cost bound.
best = trackers.best_ever
cost_bound = best.deep_copy()
# Set history and counter.
history = params['HILL_CLIMBING_HISTORY']
counter = 0
# iters is the number of individuals examined/iterations so far.
iters = len(individuals)
for generation in range(1, (params['GENERATIONS']+1)):
this_gen = []
# even though there is no population, we will take account of
# the pop size parameter: ie we'll save stats after every
# "generation"
for j in range(params['POPULATION_SIZE']):
this_gen.append(best) # collect this "generation"
# Mutate best to get candidate best.
candidate_best = params['MUTATION'](best)
if not candidate_best.invalid:
candidate_best.evaluate()
# count
if count_method == "count_all": # we count all iterations (moves)
counter += 1 # increment the counter
elif count_method == "acp": # we count accepted moves only
if candidate_best > cost_bound or candidate_best >= best:
counter += 1 # increment the counter
elif count_method == "imp": # we count improving moves only
if candidate_best > best:
counter += 1 # increment the counter
else:
s = "algorithm.hill_climbing.SCHC_search_loop\n" \
"Error: Unknown count method: %s" % (count_method)
raise Exception(s)
# accept
if candidate_best > cost_bound or candidate_best >= best:
best = candidate_best # accept the candidate
else:
pass # reject the candidate
if counter >= history:
cost_bound = best # update the bound
counter = 0 # reset the counter
# Increment iteration counter.
iters += 1
if iters >= max_its:
# We have completed the total number of iterations.
break
# Get stats for this "generation".
stats['gen'] = generation
get_stats(this_gen)
if iters >= max_its:
# We have completed the total number of iterations.
break
return individuals
def mane():
""" Run program """
# Run evolution
individuals = params['SEARCH_LOOP']()
'''
instruments = ["kick", "hh", "hhOp", "snH", "Sin1", "Sin2"]
no=1
#GRAMMAR_FILE = "ChuckGram" + str(no + 1) + ".pybnf"
resultsFile = open("../results/ChucK/ResultsFile" + str(no) + ".txt", 'w')
resultsFile.write('Gen \t Ave Fit \t Best Fit \n')
# Run evolution
#print(params)
#params["GRAMMAR_FILE"] = "ChuckGram" + str(no + 1) + ".pybnf"
individuals = params['SEARCH_LOOP']() #added no i/p by Roisin
# Print final review
get_stats(individuals, end=True)
# Read grammar
bnf_grammar = Grammar(GRAMMAR_FILE)
# Create Individuals
individuals = initialise_population(POPULATION_SIZE)
# Loop
best_ever, individuals = search_loop(GENERATIONS, individuals, bnf_grammar,
generational_replacement, tournament_selection,
FITNESS_FUNCTION, resultsFile)
#for i in individuals:
# print(i)
ind = individuals[0].phenotype
length = len(ind)
print("ind: ", ind)
i = 0
# Wrie best to file and play with midi
bestfile = open("../results/ChucK/" + instruments[no] + ".ck", 'w')
""" Separate individaul into lines and add to file"""
while i < length:
# print i
try:
end_line = ind.index(";")
# print "ind: %s end: %d, i: %d"%(ind, end_line, i)
line = ind[: end_line + 1]
print("line: ", line)
try:
if line[0] == "L":
bestfile.write("while (true) \n { \n")
line = line[1:]
except IndexError:
pass
bestfile.write(str(line))
bestfile.write("\n")
ind = ind[end_line + 1:]
except ValueError:
pass
i += end_line
bestfile.write("}")
bestfile.close()
'''
# Print final review
get_stats(individuals, end=True)
# Returns only needed if running experiment manager
return params['TIME_STAMP'], trackers.best_ever.fitness
