def hill_climber(data, prep_schedule, slot_list, course_list):
""" Climbs the hill stops when he is stuck
"""
schedule = random_schedule(prep_schedule, slot_list)
old_fitness, old_capacity_minus, old_student_minus, old_sequence_minus = fitness_function.main(schedule, course_list)
new_fitness = 0
# one step
while True:
tries = 0
# one trie
while True:
tries += 1
session_1 = random.choice(schedule)
session_2 = random.choice(schedule)
switch(session_1, session_2)
new_fitness, new_capacity_minus, new_student_minus, new_sequence_minus = fitness_function.main(schedule, course_list)
if new_fitness > old_fitness:
break
else:
switch(session_1, session_2)
if tries > 500:
return False
old_fitness = new_fitness
old_capacity_minus = new_capacity_minus
old_student_minus = new_student_minus
old_sequence_minus = new_sequence_minus
print "Total Fitness: " + str(old_fitness)
print "Capacity Conflict: " + str(old_capacity_minus)
print "Student Conflict: " + str(old_student_minus)
print "Sequence Conflict" + str(old_sequence_minus)
if old_student_minus == 0 and old_capacity_minus == 0 and old_sequence_minus == 0:
table_data = prep_table(schedule)
return table_data, old_capacity_minus, old_student_minus, old_sequence_minus
def main():
#generate initial population:
ranges = fitness_function.get_ranges()
pop_init = np.zeros(
(ga_params["n_pop"],
len(ranges))) #matrix of ones with n_pop lines and n_var columns
for i in range(len(ranges)):
var_min = ranges[i][1][0]
var_max = ranges[i][1][1]
column_i = np.random.rand(ga_params["n_pop"], 1)
if isinstance(var_min, float) or isinstance(var_max, float):
column_i = column_i * (var_max - var_min) + var_min
else:
column_i = int(round((column_i * (var_max - var_min)))) + var_min
pop_init[:, i] = column_i[:, 0]
#calculate fitness values for initial population:
fitness_init = fitness_function.main(pop_init[:, 0], pop_init[:, 1])
pop = np.append(pop_init, fitness_init, axis=1)
evolution = pop[np.argmin(pop[:, -1]), :].reshape(1, pop.shape[1])
#np.array([np.min(), np.mean(pop[:,-1])])
#generations cicle:
for gen in range(1, ga_params["n_gen"]):
#choose elements to keep for next generation (selection):
parents = selection(pop)
#pair the parents for mating (pairing):
paired_parents = pairing(parents)
#parents mating to generate new elements to complete next generation's population:
offsprings = mating(paired_parents)
offspring_results = fitness_function.main(offsprings[:, 0],
offsprings[:, 1])
offsprings = np.append(offsprings, offspring_results, axis=1)
#consolidate population (parents and offsprings):
new_pop = np.append(parents, offsprings, axis=0)
#introduce random mutation on the population:
pop = mutation(new_pop, ranges)
#determine best and average of population and save it:
evolution = np.append(evolution,
pop[np.argmin(pop[:, -1]), :].reshape(
1, pop.shape[1]),
axis=0)
#Print results:
print("Algorithm completed")
print(evolution[-1, :])
return (evolution)
def mutation(pop, ranges):
n_elems = pop.shape[0] # number of elements in the population
n_vars = pop.shape[1] - 1 # number of variables
n_mutations = round(
n_elems * n_vars *
ga_params["mut_rate"]) #number of mutations to be performed
index_best = np.argmin(
pop[:, -1]) # index of the best element in the population
# for each mutation:
for mut in range(n_mutations):
elem = round(np.random.rand() * n_elems - 1)
var = round(np.random.rand() * n_vars - 1)
#elitism:
if ga_params["elitism"] and elem == index_best:
continue
value = pop[elem, var]
if isinstance(value, float):
pop[elem, var] = (ranges[var][1][1] - ranges[var][1][0]
) * np.random.rand() + ranges[var][1][0]
else:
pop[elem, var] = int(
round((ranges[var][1][1] - ranges[var][1][0]) *
np.random.rand() + ranges[var][1][0]))
# calculate new fitness based on mutated values:
pop[elem, -1] = fitness_function.main(pop[elem, 0], pop[elem, 1])
return (pop)
def hill_climber(data, prep_schedule, slot_list, course_list):
""" Climbs the hill stops when he is stuck
"""
schedule = random_schedule(prep_schedule, slot_list)
old_fitness, old_capacity_minus, old_student_minus, old_sequence_minus = fitness_function.main(
schedule, course_list)
new_fitness = 0
# one step
while True:
tries = 0
# one trie
while True:
tries += 1
session_1 = random.choice(schedule)
session_2 = random.choice(schedule)
switch(session_1, session_2)
new_fitness, new_capacity_minus, new_student_minus, new_sequence_minus = fitness_function.main(
schedule, course_list)
if new_fitness > old_fitness:
break
else:
switch(session_1, session_2)
if tries > 500:
return False
old_fitness = new_fitness
old_capacity_minus = new_capacity_minus
old_student_minus = new_student_minus
old_sequence_minus = new_sequence_minus
print "Total Fitness: " + str(old_fitness)
print "Capacity Conflict: " + str(old_capacity_minus)
print "Student Conflict: " + str(old_student_minus)
print "Sequence Conflict" + str(old_sequence_minus)
if old_student_minus == 0 and old_capacity_minus == 0 and old_sequence_minus == 0:
table_data = prep_table(schedule)
return table_data, old_capacity_minus, old_student_minus, old_sequence_minus
rand_schedule = random_schedule(prep_schedule, slot_list)
old_generation.append(rand_schedule)
generation = 0
fitness_total = []
# print results of algo
for i in range(number_generations):
new_generation = next_generation(old_generation, slot_list)
old_generation = new_generation
fitness_list = []
capacity_list = []
student_list = []
for schedule in old_generation:
fitness, capacity_minus, student_minus = fitness_function.main(schedule)
fitness_list.append(fitness)
fitness_total.append(fitness)
capacity_list.append(capacity_minus)
student_list.append(student_minus)
print "Generation number: " + str(generation)
print "Av Fitness: " + str(sum(fitness_list) / len(fitness_list))
print "Av Capacity: " + str(sum(capacity_list) / len(capacity_list))
print "Av Student: " + str(sum(student_list) / len(student_list))
print "Best Fitness: " + str(max(fitness_list))
print "Best Capacity: " + str(min(capacity_list))
print "Best Student: " + str(min(student_list))
print "Worst Fitness: " + str(min(fitness_list))
print "Worst Capacity: " + str(max(capacity_list))
print "Worst Student: " + str(max(student_list))
print ""
rand_schedule = random_schedule(prep_schedule, slot_list)
old_generation.append(rand_schedule)
generation = 0
fitness_total = []
# print results of algo
for i in range(number_generations):
new_generation = next_generation(old_generation, slot_list)
old_generation = new_generation
fitness_list = []
capacity_list = []
student_list = []
for schedule in old_generation:
fitness, capacity_minus, student_minus = fitness_function.main(
schedule)
fitness_list.append(fitness)
fitness_total.append(fitness)
capacity_list.append(capacity_minus)
student_list.append(student_minus)
print "Generation number: " + str(generation)
print "Av Fitness: " + str(sum(fitness_list) / len(fitness_list))
print "Av Capacity: " + str(sum(capacity_list) / len(capacity_list))
print "Av Student: " + str(sum(student_list) / len(student_list))
print "Best Fitness: " + str(max(fitness_list))
print "Best Capacity: " + str(min(capacity_list))
print "Best Student: " + str(min(student_list))
print "Worst Fitness: " + str(min(fitness_list))
print "Worst Capacity: " + str(max(capacity_list))
print "Worst Student: " + str(max(student_list))
print ""
