def first_objective(self, package_amount):
simulator = Simulator()
start = time.time()
min_mean = 100000000000
best_config = []
simulation_amount = 0
for i in range(1, 31):
for j in range(1, 32):
for w in range(1, 73):
for o in range(1, 14):
config = [i, j, w, o]
if simulator.get_config_cost(config) <= 1000:
simulation_amount += 1
sr = simulator.simulate(config, package_amount, i + j + w + o)
mean = (sr[0] + sr[1] + sr[2] + sr[3]) / (4.0 * package_amount)
if mean < min_mean:
min_mean = mean
best_config = config
end = time.time()
print("Duro: " + str(end - start))
print("Media minima: " + str(min_mean))
print("Mejor configuracion: " + str(best_config))
print("Costo de la configuracion: " + str(simulator.get_config_cost(best_config)))
print("Cantidad de simulaciones: " + str(simulation_amount))
class Genetic(metaclass=ABCMeta):
def __init__(self):
self.generation_package_amount = 0
self.current_generation = 1
self.simulator = Simulator()
self.max_servers = []
self.best_individuals = []
def get_individual(self):
individual = []
for i in range(0, 4):
individual.append(random.randint(1, self.max_servers[i]))
return individual
def get_first_generation(self, size):
population = []
for i in range(0, size):
population.append(self.get_individual())
return population
@abstractmethod
def mutate(self, individual):
pass
@abstractmethod
def crossover(self, individual1, individual2):
pass
def get_next_generation(self, population, best_individual):
size = len(population)
new_population = []
for i in range(0, size):
cross = self.crossover(population[i], best_individual)
mutatation_probability = random.random()
if mutatation_probability < 0.05:
cross = self.mutate(cross)
new_population.append(cross)
self.current_generation += 1
return new_population
@abstractmethod
def get_fitness(self):
pass
def get_best_individual(self, population):
max_grade = -10000000
best_ind = []
for ind in population:
grade = self.get_fitness(ind)
if grade > max_grade:
max_grade = grade
best_ind = ind
return [best_ind, grade]
def start(self, generations):
generations_copy = generations
size = 80
population = self.get_first_generation(size)
while generations > 0:
print("Generacion #" + str((generations_copy-generations)+1))
best_individual = self.get_best_individual(population)
self.best_individuals.append(best_individual)
population = self.get_next_generation(population, best_individual[0])
generations -= 1
optimum = self.get_optimum_individual()
optimum_cost = self.simulator.get_config_cost(optimum[0])
optimum_diff = 999999999.0/(optimum[1]*optimum_cost)
print("Optimum: " + str(optimum[0]))
print("Cost: " + str(optimum_cost))
print("Diff: " + str(optimum_diff))
def get_optimum_individual(self):
best_grade = -10000
best_individual = []
best_individual_index = -1
for i in range(0, len(self.best_individuals)):
if self.best_individuals[i][1] > best_grade:
best_grade = self.best_individuals[i][1]
best_individual = self.best_individuals[i]
best_individual_index = i
print("Indice del mejor individuo: " + str(best_individual_index))
return best_individual
