def family_competition(self, k=2): parent_fitness = [(solution, Fitness.get_fitness(solution, function=self.fitness_function)) for solution in self.parent] child_fitness = [(solution, Fitness.get_fitness(solution, function=self.fitness_function)) for solution in self.children] failed_reproduction = [ baby_fitness[1] <= max(parent_fitness, key=itemgetter(1))[1] for baby_fitness in child_fitness ] family_fitness = parent_fitness + child_fitness sorted_family = sorted(family_fitness, key=lambda x: x[1], reverse=True) kth_best, kth1_best = sorted_family[k - 1], sorted_family[k] if kth_best[1] == kth_best[1]: if kth1_best[0] in self.parent and not kth_best in self.parent: sorted_family[k - 1] = kth1_best sorted_family[k] = kth_best return [solution[0] for solution in sorted_family[:k]], failed_reproduction
def set_best(self): self._best_fitness = Fitness.calculate(self.best_position) for particle in self.swarm: this_fitness = Fitness.calculate(particle.position) if this_fitness < self._best_fitness: self._best_fitness = this_fitness self.best_position = copy.deepcopy(particle.position)
def testEvalIndividualCapacityNotZero(self): ''' test that no one's perfect ''' pop = toolBox.toolbox.population(n=2) fit = Fitness() self.assertGreater(fit.evalIndividualCapacity(pop[0]), 0)
def testEvalIndividualCapacity(self): ''' test to check that no individual is assigned a fitness value less than 0 ''' pop = toolBox.toolbox.population(n=2) fit = Fitness() self.assertFalse(fit.evalIndividualCapacity(pop[0]) < 0)
def __init__(self, app_list, pe_list): self.app_list = app_list self.pe_list = pe_list self.layer_list = [l for app in app_list for l in app.layer_list] self.num_layer = len(self.layer_list) self.num_pe = len(pe_list) self.fitness = Fitness(app_list, pe_list)
def xtest_evaluate(self): ind = ConvIndividual() ind.randomInit() print(ind) fit = Fitness("data/mnist2d.train") print("evaluating") print(fit.evaluate(ind))
def xtest_evaluate(self): ind = ConvIndividual() ind.randomInit() print(ind) fit = Fitness("data/mnist2d.train") print("evaluating") print( fit.evaluate(ind) )
def testEvalIndividualCapacityZeroCapacity(self): ''' test worst case scenario - individual with zero capacity has the worst fitness ''' pop = toolBox.toolbox.population(n=2) fit = Fitness() ind1 = pop[0] ind2 = pop[1] for i, item in enumerate(ind1): ind1[i][1] = 0 self.assertGreater(fit.evalIndividualCapacity(ind1), fit.evalIndividualCapacity(ind2))
def testEvalIndividualCapacitySufficient(self): ''' test on individual that offers more than enough capacity to handle all requests ''' pop = toolBox.toolbox.population(n=2) fit = Fitness() ind1 = pop[0] ind2 = pop[1] for i, item in enumerate(ind1): ind1[i][1] = 120 self.assertGreater(fit.evalIndividualCapacity(ind2), fit.evalIndividualCapacity(ind1))
def main(): # Generate the population pop = toolBox.toolbox.population(n=POPULATION_SIZE) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean) stats.register("std", numpy.std) stats.register("min", numpy.min) stats.register("max", numpy.max) pop, log = algorithms.eaSimple(pop, toolBox.toolbox, cxpb=CROSS_OVER_PROB, mutpb=MUTATION_PROB, ngen=NO_OF_GENERATION, stats=stats, halloffame=hof, verbose=True) ## Evaluate the entire population #fitnesses = list(map(toolBox.toolbox.evaluate, pop)) #for ind, fit in zip(pop, fitnesses): # ind.fitness.values = fit # Iterate trough a number of generations # for g in range(NGEN): # print("-- Generation %i --" % g) # # Select individuals based on their fitness # offspring = toolBox.toolbox.select(pop, len(pop)) # # Cloning those individuals into a new population # offspring = list(map(toolBox.toolbox.clone, offspring)) # # Calling the crossover function # crossover(offspring) # mutation(offspring) # invalidfitness(offspring) # The Best Individual found best_ind = tools.selBest(pop, 1)[0] individual = sorted(best_ind, key=itemgetter(3)) individual = sorted(individual, key=itemgetter(0)) #print "InsertBusTrip and TimeTable......" print("Best individual is %s, %s" % (individual, best_ind.fitness.values)) print("Length of best individual: " + str(len(best_ind))) fitnessClass = Fitness() timetable = fitnessClass.genTimetable(best_ind) databaseClass = DB() #databaseClass.insertBusTrip(timetable) evaluate_timetable.eval(best_ind)
def Gera_PopInic(self, caracter, TAM_Pop, NUM_CROM): # Gera uma população inicial for x in range(0, TAM_Pop): # Laço para IND = Individuo(caracter) # Variável recebe indivíduo F = Fitness( self.Frase, NUM_CROM) # A Variável F recebe instancia da classe fitness self.listPop.append( F.Calc_Fitness(IND.Gera_Individuo(NUM_CROM)) ) # Adiciona o individuo na lista de populações e calcula o Fitness print(self.listPop[x]) # imprimi o indivíduo return self.listPop # retorna a lista de indivíduos
def main(): # Generate the population pop = toolBox.toolbox.population(n=POPULATION_SIZE) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean) stats.register("std", numpy.std) stats.register("min", numpy.min) stats.register("max", numpy.max) pop, log = algorithms.eaSimple(pop, toolBox.toolbox, cxpb=CROSS_OVER_PROB, mutpb=MUTATION_PROB, ngen=NO_OF_GENERATION, stats=stats, halloffame=hof, verbose=True) ## Evaluate the entire population #fitnesses = list(map(toolBox.toolbox.evaluate, pop)) #for ind, fit in zip(pop, fitnesses): # ind.fitness.values = fit # Iterate trough a number of generations # for g in range(NGEN): # print("-- Generation %i --" % g) # # Select individuals based on their fitness # offspring = toolBox.toolbox.select(pop, len(pop)) # # Cloning those individuals into a new population # offspring = list(map(toolBox.toolbox.clone, offspring)) # # Calling the crossover function # crossover(offspring) # mutation(offspring) # invalidfitness(offspring) # The Best Individual found best_ind = tools.selBest(pop, 1)[0] individual = sorted(best_ind, key=itemgetter(3)) individual = sorted(individual, key=itemgetter(0)) #print "InsertBusTrip and TimeTable......" print("Best individual is %s, %s" % (individual, best_ind.fitness.values)) print ("Length of best individual: " + str(len(best_ind))) fitnessClass = Fitness() timetable = fitnessClass.genTimetable(best_ind) databaseClass = DB() #databaseClass.insertBusTrip(timetable) evaluate_timetable.eval(best_ind)
def localSearch(self, solution, solution_fitness, materials_changed): new_concept_coverage = solution new_best_fitness = solution_fitness for j in range(self.local_search_size): fitness_improved = False for material in materials_changed: for concept in range(num_concepts): step_concept_coverage = new_concept_coverage.copy() step_concept_coverage[ material, concept] = ~step_concept_coverage[material, concept] step_fitness = sum([ Fitness.get_fitnessConcepts(student_id, step_concept_coverage.T) for student_id in range(num_students) ]) / num_students if new_best_fitness > step_fitness: new_best_fitness = step_fitness new_concept_coverage = step_concept_coverage fitness_improved = True if not fitness_improved: break return new_concept_coverage, new_best_fitness
def __start__(self): for i in self.tqdm: for p in self.population: fitness = Fitness(self.population[p]) selection = self.__selection__(self.population[p]) crossover = self.__crossover__(selection, self.population[p]) mutation = self.__mutation___(crossover)
def run(self, X, Y): self.fitfun = Fitness(X, Y) self.evolops = Evol_operators(self.degree_range, 1, self.max_terms) self.pop = self._create_init_pop() for g in range(self.gens): ftournament = lambda x, y: x if x.fitness < y.fitness else y childs = self.pop #crossover #childs = self._apply_crossover(childs, ftournament) #mutação childs = self._apply_mutation(childs) self.pop = self._apply_tourn_sel(childs + self.pop, ftournament) self.printInfo(g) if self.log != None: df = pd.DataFrame(self.results) df.to_csv(self.log, index=False) return self
def rankRoutes(population): fitnessResults = {} for i in range(0, len(population)): fitnessResults[i] = Fitness(population[i]).routeFitness() return sorted(fitnessResults.items(), key=operator.itemgetter(1), reverse=True)
def rank_routes(self, population): # Calcula o custo de cada rota e ranqueia do melhor(menor) pro pior(maior) fitness_results = {} for i in range(0, len(population)): fitness_results[i] = Fitness(population[i]).route_fitness() return sorted(fitness_results.items(), key=lambda x: x[1], reverse=True)
def rankRoutes( population): #kanoume rank ta routes/inidividuals TOU population fitnessResults = {} #edo mesa exei ta routes taksinomimena for i in range(0, len(population)): fitnessResults[i] = Fitness(population[i]).routeFitness() return sorted(fitnessResults.items(), key=operator.itemgetter(1), reverse=True)
def __init__(self, position): self._position = position self._dimensions = len(position) self._best_position = position self._best_fitness = Fitness.calculate(position) self._velocity = [ self.get_random_velocity() for _ in range(self._dimensions) ]
def main(): fitnessClass =Fitness() # Generate the population pop = toolBox.toolbox.population(n=POPULATION_SIZE) fitnessClass.evalIndividualCapacity(pop[0]) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean) stats.register("std", numpy.std) stats.register("min", numpy.min) stats.register("max", numpy.max) pop, log = algorithms.eaSimple(pop, toolBox.toolbox, cxpb=CROSS_OVER_PROB, mutpb=MUTATION_PROB, ngen=NO_OF_GENERATION, stats=stats, halloffame=hof, verbose=True) ## Evaluate the entire population #fitnesses = list(map(toolBox.toolbox.evaluate, pop)) #for ind, fit in zip(pop, fitnesses): # ind.fitness.values = fit # Iterate trough a number of generations # for g in range(NGEN): # print("-- Generation %i --" % g) # # Select individuals based on their fitness # offspring = toolBox.toolbox.select(pop, len(pop)) # # Cloning those individuals into a new population # offspring = list(map(toolBox.toolbox.clone, offspring)) # # Calling the crossover function # crossover(offspring) # mutation(offspring) # invalidfitness(offspring) # The Best Individual found best_ind = tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % (best_ind, best_ind.fitness.values)) generateTimeTable(best_ind)
def generateBusTrip(self, trip): fitness = Fitness() db = DB() line = 0 count = 0 chromosome = [] for tripInstance in trip: for busInstance in tripInstance[3]: if line != busInstance["line"] and count != 0: chromosome.append([line, capacity, self.calculateFrequency(count), startTime]) count = 0 if count == 0: capacity = busInstance["capacity"] startTime = busInstance["startTime"] line = busInstance["line"] count += 1 chromosome.append([line, capacity, self.calculateFrequency(count), startTime]) individual = fitness.genTimetable(chromosome) db.insertBusTrip2(individual)
def test(self): seq = [[[16, 94], [41, 75], [25, 116], [29, 91], [28, 78], [35, 75]], [[22, 53], [32, 116], [43, 106]], [[38, 105], [37, 43], [18, 109], [12, 82], [50, 75]], [[6, 120], [54, 70], [32, 98], [50, 97], [26, 80]], [[13, 105], [30, 112], [31, 100]], [[23, 71], [32, 89], [29, 91], [22, 59]], [[38, 91], [38, 98], [11, 203], [24, 105], [25, 111], [54, 78], [44, 85], [49, 82], [58, 72], [30, 86], [22, 112]]] f = Fitness(DNA(seq)) print(f.fitness)
def __init__(self, max_generations: int, start_population: int, base_gene_chain: GeneChain, crosser: Crosser, selector: Selector, mutator: Mutator, verbose: bool = True): self._selector = selector self._crosser = crosser self._mutator = mutator self._fitness = Fitness() self._max_generations = max_generations self._verbose = verbose # Create random individuals self._individuals = [ deepcopy(base_gene_chain) for i in range(start_population) ] for individ in self._individuals: individ.random()
def rankRoutes(population): ''' rankRoutes function ''' # Initial dict fitnessResutsDict = dict() for i in xrange(0, len(population)): fitnessResutsDict[i] = Fitness(population[i]).routeFitness() return sorted(fitnessResutsDict.items(), key=operator.itemgetter(1), reverse=True)
def __convert_fitness_j_to_p(self, f): return Fitness(value=get_field(f, "value"), u_sell=get_field(f, "uSell"), u_buy=get_field(f, "uBuy"), noop=get_field(f, "noop"), realised_profit=get_field(f, "realisedProfit"), mdd=get_field(f, "MDD"), ret=get_field(f, "Return"), wealth=get_field(f, "wealth"), no_of_transactions=get_field(f, "noOfTransactions"), no_of_short_selling_transactions=get_field( f, "noOfShortSellingTransactions"))
class Heuristic(MapFunc): def __init__(self, app_list, pe_list): self.app_list = app_list self.pe_list = pe_list self.layer_list = [l for app in app_list for l in app.layer_list] self.num_layer = len(self.layer_list) self.num_pe = len(pe_list) self.fitness = Fitness(app_list, pe_list) def do_schedule(self): self.mapping = [0] * len(self.layer_list) self._set_initial_mapping() if self._pass_constraint(): self.fitness.calculate_fitness(self.mapping) return [self.mapping] else: return [] # no solution def _set_initial_mapping(self, mapping): raise NotImplementedError def _pass_constraint(self, mapping): raise NotImplementedError
def run(self, concept_coverage, fitnessConcepts_total, DATFILE=None): best_solution = concept_coverage best_fitness = fitnessConcepts_total current_temperature = self.initial_temperature current_solution = concept_coverage current_fitness = fitnessConcepts_total self.get_orderOfModifiedMaterials() fitness_progress = np.empty(self.max_iterations) for i in range(self.max_iterations): for l in range(self.cycle): next_solution = self.get_randNeighbor(best_solution) next_fitness = sum([ Fitness.get_fitnessConcepts(student_id, current_solution.T) for student_id in range(num_students) ]) / num_students deltaE = next_fitness - current_fitness if (deltaE < 0.0): current_solution = next_solution current_fitness = next_fitness if (next_fitness < best_fitness): best_solution = next_solution best_fitness = next_fitness else: if (random.uniform(0, 1) < math.exp( -deltaE / current_temperature)): current_solution = next_solution current_fitness = next_fitness current_temperature = self.decreaseTemperature(current_temperature) fitness_progress[i] = best_fitness # print("current_temperature: ", current_temperature) if (DATFILE): with open(DATFILE, 'w') as f: f.write(str(best_fitness)) else: with open('results_SA.pickle', 'wb') as file: pickle.dump( { "fitness_progress": fitness_progress, "sa_concept_coverage": best_solution, "sa_fitness": best_fitness }, file) return best_solution, best_fitness
class Genetic: def __init__(self, max_generations: int, start_population: int, base_gene_chain: GeneChain, crosser: Crosser, selector: Selector, mutator: Mutator, verbose: bool = True): self._selector = selector self._crosser = crosser self._mutator = mutator self._fitness = Fitness() self._max_generations = max_generations self._verbose = verbose # Create random individuals self._individuals = [ deepcopy(base_gene_chain) for i in range(start_population) ] for individ in self._individuals: individ.random() def _next_generation(self): # cross individ self._individuals = self._crosser.cross(self._individuals) # add mutatation self._individuals += self._mutator.mutate(self._individuals) # calculate fitness function for each indidivid for individ in self._individuals: individ.score = self._fitness.calc(individ) # sort individ by score self._individuals.sort(key=lambda i: i.score, reverse=True) # get best individ self._individuals = self._selector.select(self._individuals) def run(self): start_time = time() for i in range(self._max_generations): self._next_generation() if self._verbose: print("Generation:", i + 1, "| Fitness:", round(self._individuals[0].score), "(%ss.)" % round(time() - start_time)) start_time = time() def best(self): return self._individuals[0]
def generateBusTrip(self, trip): fitness = Fitness() db = DB() line = 0 count = 0 chromosome = [] for tripInstance in trip: for busInstance in tripInstance[3]: if line != busInstance["line"] and count != 0: chromosome.append([ line, capacity, self.calculateFrequency(count), startTime ]) count = 0 if count == 0: capacity = busInstance["capacity"] startTime = busInstance["startTime"] line = busInstance["line"] count += 1 chromosome.append( [line, capacity, self.calculateFrequency(count), startTime]) individual = fitness.genTimetable(chromosome) db.insertBusTrip2(individual)
def gera_Mutacao(self, Frase): # Método para gerar mutação no filhos listaTmp = [] listaFin = [] listaFinal = [] TX_Mut_A = round(random.random()) # Número aleatorio entre 0 e 1 for x in self.lista_Filho: if(TX_Mut_A <= self.TX_Mutac): # Se o número aleatorio for menor e igual que taxa de mutação, o indivíduo sofre a mutação em 2 duas posições aleatorias x1 = random.randint(0, self.NUM_CROM-1) # x1 = valor de posição aleatoria x2 = random.randint(0, self.NUM_CROM-1) # x2 = valor de posição aleatoria I = Individuo(self.Caract) # instancia clase indivíduo x[x1] = I.get_caracter() # Modifica o caracter na posição x1 por um novo caracter na mesma posição x[x2] = I.get_caracter() # Modifica o caracter na posição x2 por um novo caracter na mesma posição F = Fitness(Frase, self.NUM_CROM) # Recalcula o Fitness listaTmp.append(F.Calc_Fitness(x)) else: # Caso a condição não seja aceita listaTmp.append(x) # Adicione o indivíduo na lista sem alteração print('Mutação nos Filhos') # imprimi os filhos com ou sem mutação for y in listaTmp: print(y) for z in self.lista_Selec: # Adiciona os filhos e pais dentro de uma lista listaFin.append(z) for z in listaTmp: listaFin.append(z) listaFin.sort(key=lambda x: x[self.NUM_CROM]) # Ordena a lista de pais e filhos for x in range(self.TAM_Pop, len(listaFin)): # gera uma lista com o melhor dos pais e filhos listaFinal.append(listaFin[x]) print('Nova População') # imprimi a lista com os melhores for y in listaFinal: print(y) return listaFinal # retorna a lista com nova população
def greadyRandomizedConstruction(self): student_yes = np.matmul( recommendation.astype(int), objectives.astype(int) ) #quantos alunos receberam o material E o tem como objetivo student_no = np.matmul( recommendation.astype(int), (~objectives).astype(int) ) #quantos alunos receberam o material E não o tem como objetivo student_difference = student_no - student_yes #(quantos alunos querem ter o conveito adicionado) - (quantos alunos querem ter o conceito removido) scaled_coverage = (concept_coverage * 2 - 1 ) # concept_coverage, onde False é -1 e True é 1 conflicts = student_difference * scaled_coverage change_potential = np.maximum(0, conflicts).sum(axis=1) materials_changed = [] new_concept_coverage = concept_coverage.copy() change_potential_order = np.argsort(-change_potential).tolist() for j in range(int(self.max_materials_changes * num_materials)): # Select a material and remove from the list selected_material_index = random.randrange( int(len(change_potential_order) * self.alpha_m)) material = change_potential_order[selected_material_index] materials_changed.append(material) del change_potential_order[selected_material_index] # print('[', material, change_potential[material], ']') # print(conflicts[material]) conflicts_order = np.argsort(-conflicts[material]).tolist() for k in range(int(self.max_concepts_changes * num_concepts)): # Select a concept from the material and remove from the list selected_concept_index = random.randrange( int(len(conflicts_order) * self.alpha_c)) concept = conflicts_order[selected_concept_index] del conflicts_order[selected_concept_index] # print(material, concept) if conflicts[material, concept] > 0: new_concept_coverage[ material, concept] = ~new_concept_coverage[material, concept] new_best_fitness = sum([ Fitness.get_fitnessConcepts(student_id, new_concept_coverage.T) for student_id in range(num_students) ]) / num_students return new_concept_coverage, new_best_fitness, materials_changed
def calculate_average_fitness(tfitnesses, log_path): Avalue = 0 Au_sell = 0 Au_buy = 0 Anoop = 0 Arealised_profit = 0 Amdd = 0 Aret = 0 Awealth = 0 Ano_of_transactions = 0 n_runs = len(tfitnesses) """ Calculates an average fitness and logs it to file """ for f in tfitnesses: Avalue += tfitnesses[f].value Au_sell += tfitnesses[f].u_sell Au_buy += tfitnesses[f].u_buy Anoop += tfitnesses[f].noop Arealised_profit += tfitnesses[f].realised_profit Amdd += tfitnesses[f].mdd Aret += tfitnesses[f].ret Awealth += tfitnesses[f].wealth Ano_of_transactions += tfitnesses[f].no_of_transactions Af = Fitness(value=Avalue / n_runs, u_sell=Au_sell / n_runs, u_buy=Au_buy / n_runs, noop=Anoop / n_runs, realised_profit=Arealised_profit / n_runs, mdd=Amdd / n_runs, ret=Aret / n_runs, wealth=Awealth / n_runs, no_of_transactions=Ano_of_transactions / n_runs) open(log_path + 'results.txt', 'w').close() with open(log_path + 'results.txt', 'a') as f: f.write( "file\tnumber of runs\tavg wealth\tavg return\tavg value\tavg profit\tavg mdd\tavg transactions\tavg short transactions\n" ) f.write("%s\t%d\t%s" % (log_path, n_runs, Af)) pickle.dump(Af.__dict__, open(log_path + "pickles/average_fitness.pickle", "wb"))
def inferBestCMu(self, samples, currentGraph): #import threading import time start_time = time.time() fitness = Fitness() threads = [] #can we run the method for each sample in parallel? This would speed up the process by a lot. THe samples are not dependent on each other! for sampleInd in range( 1, len(samples)): #Skip the first 'dummy' precursor sample self.inferBestCMuPerSample(samples, sampleInd, currentGraph, fitness) #t = threading.Thread(target=self.inferBestCMuPerSample, args=[samples,sampleInd,currentGraph, fitness]) #threads.append(t) #t.start() #for thread in threads: # thread.join() #After we have inferred the best C and mu for each sample, we can update the best C and mu in the samples. for sample in range(0, len(samples)): samples[sample].originalCMu = samples[sample].bestCMu if samples[sample].bestCMu is None: measurementLength = len(samples[0].measurements.measurements) samples[sample].Mu = Mu(0) #assume 100% tumor #Set a default bestCMu in this case, we don't know the solution. print "sample ", sample, " setting CMu to 2" samples[sample].bestCMu = [ CMuCombination(C([2, 2]), Mu(0), self.eventDistances) ] * measurementLength else: if samples[sample].bestCMu[0] is not None: print "setting mu to: ", samples[sample].bestCMu[ 0].mu.mu, " in sample: ", samples[sample].name samples[sample].Mu = samples[sample].bestCMu[0].mu else: #without a successfully inferred C and mu the sample is so complex it is most likely 100% tumor or contains a lot of subclones. print sample, " Assuming 100% tumor" samples[sample].Mu = Mu(0) #assume 100% tumor print("--- %s seconds for all samples of 1 patient ---" % (time.time() - start_time)) return samples
def __init__(self, app_list, pe_list): # about app self.app_list = app_list self.layer_list = [l for app in app_list for l in app.layer_list] self.pe_list = pe_list self.num_app = len(app_list) self.num_layer = len(self.layer_list) self.num_pe = len(pe_list) # about scheduling self.optimistic_cost_table = list() # for speed up self.optimistic_cost_hash = dict() self.processor_available_time_list = [0] * self.num_pe self.mapped_layers_per_pe = [[] for _ in range(self.num_pe)] self.fitness = Fitness(app_list, pe_list) self.mappings = list() self.target_range_divider = 5 # XXX: generate maximum 1+n (= initial + moving_coverate) mappings self.moving_coverage = 2 self.interference_fortify = 2
def main(): parser = argparse.ArgumentParser(description='Tweak GA parameters') parser.add_argument('-size','--populationSize', type=int, required=False, default=100, help = 'Desired population size (int)') parser.add_argument('-iter','--maxIter', type=int, required=False, default=100, help = "Max number of iterations allowed (int)") parser.add_argument('-n','--n', type=int, required=False, default=10, help = 'Desired number of neural_networks in the hidden layer') parser.add_argument('-k','--K', type=float, required=False, default=1.1, help = "Chromosome is mutated by adding a number from the normal_distibution(0,K) to it's weights value") parser.add_argument('-err','--errThreshold', type=float, required=False, default=0.1, help = "Algorithm stops search if it has found a chromosome with error less than errThreshold") parser.add_argument('-train','--trainSet', type=str, required=False, default="learningSet/train-set.txt", help = "Path to training_set") #parser.add_argument('-test','--testSet', type=str, required=False, default="learningSet/test-set.txt", # help = "Path to test_set") args = parser.parse_args() ERR_THRESHOLD = args.errThreshold VEL_POP = args.populationSize MAX_ITER = args.maxIter N = args.n K = args.K train_set = parseLearningSet(args.trainSet) ## initialize needed operators fitnessOp = Fitness(train_set) mutationOp = Mutation(K, N, VEL_POP) ##initialize population P = Population(N, VEL_POP) ##returns best neural_network (individual) best_nn = run_GA(P, fitnessOp, mutationOp, VEL_POP, MAX_ITER, ERR_THRESHOLD) test_set = [] # parseLearningSet(args.testSet) test_dict = {} #parseLearningDict(args.testSet) writeOut(best_nn, test_set, test_dict)
def __results__(self): fitness = dict( map(lambda x: (x, Fitness(self.population[x])), self.population)) fitness_global = dict( map( lambda x: (x, { "makespan_glob": [ round(max(fitness[x].makespan), 2), round(min(fitness[x].makespan), 2) ], "energyCons_glob": [ round(max(fitness[x].energyCons), 2), round(min(fitness[x].energyCons), 2) ], "bt_makespan_energyCons": [ round( fitness[x].makespan[np.argmin(fitness[ x].makespan + fitness[x].makespan)], 2), round( fitness[x].energyCons[np.argmin(fitness[ x].makespan + fitness[x].energyCons)], 2) ] }), fitness)) pprint(fitness_global)
def geraCruzamento(self, Frase): # Método para gera os filhos x1 = 4 # Ponto de corte 1 x2 = 9 # Ponto de corte 2 x3 = 14 # Ponto de corte 3 cnt = 0 listTmp = [] while ( len(listTmp) < self.Tamanho_Populacao ): # lopp. Enquanto o tamanho da lista filhos for menor que tamanho da população ind = self.populacao[ cnt] # Variável 'ind' recebe o primeiro indivíduo p1 = ind[:x1] # corta o indivíduo em 3 pontos p2 = ind[x1:x2] p3 = ind[x2:x3] # cnt += 1 ind = self.populacao[ cnt] # Variável 'ind' recebe o segundo indivíduo p4 = ind[0:x1] # corta o indivíduo em 3 pontos p5 = ind[x1:x2] p6 = ind[x2:x3] # t1 = p1 + p5 + p3 # Produz um novo indivíduo(filho) com as partes cortadas t2 = p4 + p2 + p6 # Produz um novo indivíduo(filho) com as partes cortadas t1.append(0) # Adiciona o valor 0 do fitness ao individuo 1 t2.append(0) # Adiciona o valor 0 do fitness ao individuo 2 F = Fitness(Frase, self.numCrom) # Calcula o fitness dos indivíduos listTmp.append( F.Calc_Fitness(t1)) # Adiciona o indivíduo na lista de filhos F = Fitness(Frase, self.numCrom) # Calcula o fitness dos indivíduos listTmp.append( F.Calc_Fitness(t2)) # Adiciona o indivíduo na lista de filhos # repete o procedimento com mais dois individuos print("filhos") # imprimi a lista de filhos for i in listTmp: print(i) return listTmp
def testTimeDiffNeg(self): fit = Fitness() self.assertEqual(fit.timeDiff('08:00', '08:01'), timedelta(minutes=-1))
def testTimeDiffEq(self): fit = Fitness() self.assertEqual(fit.timeDiff('00:00', '00:00'), timedelta(hours=0, minutes=0))
def testTimeDiffPos(self): fit = Fitness() self.assertEqual(fit.timeDiff('23:59', '00:00'), timedelta(hours=23, minutes=59))
type=float, help='Final temperature') ap.add_argument('-a', '--alpha', type=float, default=0.90, help='alpha') ap.add_argument('-b', '--beta', type=str, default=0.2, help='beta') ap.add_argument('--datfile', dest='datfile', type=str, help='File where it will be save the score (result)') args = ap.parse_args() if args.verbose: logging.basicConfig(level=logging.DEBUG) logging.debug(args) student_results_before = sum([ Fitness.get_fitnessConcepts(student_id, concept_coverage.T) for student_id in range(num_students) ]) / num_students simulatedAnnealing = SimulatedAnnealing(args.max_iterations, args.cycle, args.initial_temperature, args.final_temperature, args.alpha, args.beta, 0.0356, 0.1667, 98092891) simulatedAnnealing.run(concept_coverage, student_results_before, args.datfile) # annealing_concept_coverage, student_results_annealing = simulatedAnnealing.run(concept_coverage, student_results_before) # print(f'student_results_annealing: {student_results_annealing}')