def grid_deployment(f):
scenarios.generate_victim_positions_traces()
iteractions = 50
list_solutions = list()
list_fitness = list()
for i in range(0, iteractions):
sol, fit = algorithms.simple_grid()
list_solutions.append(sol)
list_fitness.append(fit)
length = len(list_fitness)
mean = sum(list_fitness) / length
sum2 = sum(x * x for x in list_fitness)
std = abs(sum2 / length - mean**2)**0.5
f.write("Results \n")
f.write("Max, Min, Mean, Std \n")
f.write(
str(max(list_fitness)) + "," + str(min(list_fitness)) + "," +
str(mean) + "," + str(std))
f.write("\n")
global_max = max(list_fitness)
index = miscelleneous.find_max(list_fitness)
plots.print_drones_data(list_solutions[index], f)
f.write("simple grid deployment")
f.write("\n")
def only_local(option, f):
knowledge = 0
iterations_local = 50 # number of trials
scenarios.generate_victim_positions_traces()
scenarios.partial_knowledge_generation(knowledge)
list_best_individuals = list()
list_best_fitness = list()
list_evolution_max = list()
list_best_time = list()
for i in range(0, iterations_local):
list_drones = quality.init(
global_variables.num_drones) # random selection
global_variables.partial = 1
result_global = quality.evaluate(list_drones)
global_variables.partial = 1 # we evaluate the hill climbing
type_global = "Genetic Algorithm"
if option == "Hill":
type_local = "Hill Climbing"
list_drones_climbing, records = local.hill_climbing(
list_drones, result_global)
list_best_individuals.append(list_drones_climbing)
#list_best_time.append(best_time)
q, = quality.evaluate(list_drones_climbing)
list_best_fitness.append(q)
list_evolution_max.append(records)
length = len(list_best_fitness)
mean = sum(list_best_fitness) / length
sum2 = sum(x * x for x in list_best_fitness)
std = abs(sum2 / length - mean**2)**0.5
index = miscelleneous.find_max(list_best_fitness)
f.write(type_local)
f.write("\n")
f.write("Results \n")
f.write("Max, Min, Mean, Std \n")
f.write(
str(max(list_best_fitness)) + "," + str(min(list_best_fitness)) + "," +
str(mean) + "," + str(std))
f.write(str(list_best_fitness))
plots.print_drones_data(list_best_individuals[index], f)
plots.evolution_local(list_evolution_max[index], type_local)
plots.positions(list_drones, list_best_individuals[index], type_global,
type_local)
def simulated_annealing(lista_drones, global_max, deviation):
""" Simulated annealing algorithm. It receives the list of drones and the global maximum"""
max_speed = 10 # meters/seconds
simulation_time = 10000 # seconds
global_variables.partial = 0
temperature = float(deviation) / 0.0953
records = []
records_positions = []
records_probability = []
records_temperature = []
records_aux = []
global_max2, = global_max
first_max = global_max
max_list = copy.deepcopy(lista_drones) # watch up
records.append(global_max2)
records_positions.append(max_list)
choose_directions(lista_drones, max_speed)
print("---------- START SIMULATED ANNEALING OPTIMIZATION ----------")
for i in range(0, simulation_time):
update_drones_positions(lista_drones)
current_quality, = quality.evaluate(lista_drones)
if current_quality <= global_max2 and current_quality > 0:
probability = calculate_annealing_probability(
temperature, current_quality, global_max2)
print(probability)
records_probability.append(probability)
#records_aux.append(aux)
if (probability >=
random.random()): # we should avoid non valid solutions
print("----------------accepting a WORSE solution--------")
print("----------------previous quality %f" % global_max2)
global_max2 = current_quality
records.append(global_max2)
prueba = copy.deepcopy(lista_drones)
records_positions.append(prueba)
print("----------------new quality %f" % global_max2)
plots.print_drones_data(lista_drones, 0)
print("-----------------------------------------------")
print("-----------------------------------------------")
else:
step_back(lista_drones, max_speed)
else:
if (current_quality > 0):
print("----------------accepting a BETTER solution--------")
print("----------------previous quality %f" % global_max2)
global_max2 = current_quality
prueba = copy.deepcopy(lista_drones)
records.append(global_max2)
records_positions.append(prueba)
print("----------------new quality %f" % global_max2)
plots.print_drones_data(prueba, 0)
print("-----------------------------------------------")
print("-----------------------------------------------")
temperature = update_annealing_temperature(temperature, deviation,
simulation_time)
records_temperature.append(temperature)
print("temperature %f" % temperature)
#plots.evolution_local(records_aux, "probability")
index = miscelleneous.find_max(records)
print("quality before simulated annealing %f" % first_max)
print("List of victims covered %s" %
quality.calc_victims_covered(max_list))
print("total number of victims covered %d" %
len(quality.calc_victims_covered(max_list)))
print("-------INITIAL POSITIONS----------------------")
plots.print_drones_data(max_list, 0)
print("----------------------------------------------")
print("----------------------------------------------")
print("final quality simulated annealing %f" % records[index])
print("List of victims covered %s" %
quality.calc_victims_covered(records_positions[index]))
print("total number of victims covered %d" %
len(quality.calc_victims_covered(records_positions[index])))
print("-------FINAL POSITIONS----------------------")
plots.print_drones_data(records_positions[index], 0)
print("----------------------------------------------")
print("----------------------------------------------")
return records_positions[index], records
def global_plus_local(f):
""" This function runs the whole approach global + local search """
iterations_genetic = 1 # iterations genetic algorithm
knowledge = 0.8 # level of knowledge
list_best_individuals = list(
) # to store the best individual of each genetic algorithm run
list_best_fitness = list(
) # to store the best fitness of the best individual of each run
list_generations = list() # to store the generations
list_drones_climbing = list()
list_evolution_max = list()
type_global = "Genetic"
type_local = "Hill Climbing"
f.write(type_global)
f.write("\n")
scenarios.generate_victim_positions_traces()
scenarios.partial_knowledge_generation(knowledge)
for i in range(0, iterations_genetic):
individual, fitness, generation, evol_max = genetic.genetic_algorithm(
"global_plus_local", i, knowledge)
list_best_individuals.append(individual)
list_best_fitness.append(fitness)
list_generations.append(generation)
list_evolution_max.append(evol_max)
length = len(list_best_fitness)
mean = sum(list_best_fitness) / length
sum2 = sum(x * x for x in list_best_fitness)
std = abs(sum2 / length - mean**2)**0.5
f.write("Results \n")
f.write("Max, Min, Mean, Std \n")
f.write(
str(max(list_best_fitness)) + "," + str(min(list_best_fitness)) + "," +
str(mean) + "," + str(std))
f.write("\n")
global_max = max(list_best_fitness)
index = miscelleneous.find_max(list_best_fitness)
plots.print_drones_data(list_best_individuals[index], f)
# LOCAL
f.write(type_local)
f.write("\n")
#list_dr = quality.init_modified(list_best_individuals[index], global_variables.num_drones) # To simulate different number of drones for the initial deployment and for the adaptation to the real conditions
#list_drones_climbing, records = local.hill_climbing(list_dr, list_best_individuals[index].fitness.values)
list_drones_climbing, records = local.hill_climbing(
list_best_individuals[index],
list_best_individuals[index].fitness.values)
f.write("Results \n")
f.write(str(quality.evaluate(list_drones_climbing)))
plots.print_drones_data(list_drones_climbing, f)
plots.positions(list_best_individuals[index], list_drones_climbing,
type_global, type_local)
plots.evolution_local(records, type_local)
plots.evolution_global(list_evolution_max[index], type_global)
print("######### FIRST DEPLOYMENT STATISTICS ################")
print(" Min %s" % min(list_best_fitness))
print(" Max %s" % max(list_best_fitness))
print(" Avg %s" % mean)
print(" Std %s" % std)