def local_search(pokemons, team_selection, iterations=1000): """ :param pokemons: The structure of the Singleton :param team_selection: The first generated team to try counter :param iterations: The max number of iterations of the local search, by default 1000 :return: A tuple with best team and this fit """ best_evaluation_local = fitness(team_selection, pokemons) best_team_selection = team_selection.copy() for i in range(iterations): mutations = randrange(len(team_selection)) + 1 while mutations > 0: mutations -= 1 team_selection = mutate_team(team_selection) get_fitness = fitness(team_selection, pokemons) if get_fitness > best_evaluation_local: best_evaluation_local = get_fitness best_team_selection = team_selection.copy() return best_team_selection, best_evaluation_local
def update(self, gbest): self.r1 = random.uniform(0, 1) self.r2 = random.uniform(0, 1) inertiaFactor = self.omega * self.velocity cognitiveFactor = self.alfa * self.r1 * (self.pbest[0] - self.position) socialFactor = self.beta * self.r2 * (gbest - self.position) self.velocity = inertiaFactor + cognitiveFactor + socialFactor self.position = self.position + self.velocity if fitness(self.position.values) > self.pbest[1]: self.pbest = (self.position, fitness(self.position.values))
def get_fitness_for_single_solution(summ): sys_tf = get_TF(summ, vocab) #ref_tf is globally defined fit = fitness(sys_tf, ref_tf) return fit
def __init__(self, N): self.N = N self.position = Position() self.position.values = generateRandomPosition(N) self.velocity = Velocity() self.velocity.values = generateRandomSwap(N) self.pbest = (self.position, fitness(self.position.values)) self.omega = 0.7 self.alfa = 1.2 self.beta = 2.3
def solve(self): maxIteration = 1000 for _ in range(maxIteration): self.iteration += 1 for g_ind in range(len(self.genomes)): g = self.genomes[g_ind] g1 = self.genomes[random.randint(0, self.numberOfGenomes - 1)] g2 = self.genomes[random.randint(0, self.numberOfGenomes - 1)] g3 = self.genomes[random.randint(0, self.numberOfGenomes - 1)] donor = self.generateDonor(g1, g2, g3) trial = self.generateTrial(g, donor) if fitness(g) < fitness(trial): self.genomes[g_ind] = trial if fitness(self.solution) < fitness(trial): self.solution = trial if self.chartGen and self.iteration % 10 == 0: self.generateValuesToChart()
def weight(individual, data): x = data[0] y = data[1] #tree = PrimitiveTree(individual) #tree. func = toolbox.compile(expr=individual) #print(type(func)) #print(individual) pred = func(x, y) label = objective(x, y) loss = fitness(pred, label) return loss,
def f_fitness(vars): alfa = vars[0] beta = vars[1] gamma = vars[2] v_apts = np.zeros(n) scheds = np.random.choice(np.arange(0, N), size=n) for i, s in enumerate(scheds): l = lens[s] if m_t[s,l-1] < interrev: continue srga = SM2(alfa, beta, gamma) v_apts[i] = fitness(s, m_t[s,:l], m_acum_cs[s, -1], m_acum_ss[s, -1], srs=srga) return np.average(v_apts)
def main(): # Cargamos datos m_t = np.load('SRS/data/times.npy') m_c = np.load('SRS/data/correct.npy') m_s = np.load('SRS/data/seen.npy') m_d = np.load('SRS/data/lexemes_dificulty.npy') lens = np.load('SRS/data/len_schedule.npy') lens = lens.astype(int) # Armamos un schedule, parecido a un uniforme ts_revs = np.array([0, 3600 * 36, 3600 * 50, 3600 * 72, 3600 * 84]) * 10 c = np.ones(5) * 4 n = np.ones(5) * 8 nvent = 5 # Creamos un SRS uniforme uniforme = Uniforme(24 * 3600) (revs, apt) = fitness(ts_revs, c, n, uniforme, return_revs=True) print(f'aptitud: {apt}')
def f_fitness(vars): alfa0 = vars[0] umbral = vars[1] phi = vars[2:7] psi = vars[7:] srga = SRGA(alfa0, phi, psi, umbral) v_apts = np.zeros(n) scheds = np.random.choice(part, size=n) for i, s in enumerate(scheds): l = lens[s] if m_t[s, l - 1] < interrev: continue v_apts[i] = fitness(s, m_t[s, :l], m_acum_cs[s, -1], m_acum_ss[s, -1], srs=srga) return np.average(v_apts)
def show_crows(solutions): print("SOLUTIONS") for i in range(solutions.shape[0]): print(solutions[i]) print(fitness(matrix, solutions[i]))
def main(): #Cargar las matrices m_t, m_c, m_s y a lens m_t = np.load('SRS/data/times.npy') m_c = np.load('SRS/data/correct.npy') m_s = np.load('SRS/data/seen.npy') lens = np.load('SRS/data/len_schedule.npy') lens = lens.astype(int) #Cargamos los acums ("ASCO") m_acum_cs = np.load('SRS/data/acum_c-res1000-sigma30.npy') m_acum_ss = np.load('SRS/data/acum_s-res1000-sigma30.npy') # NUMEROS MAGICOS N = m_t.shape[0] #Cantidad total de schedules n = 10 #Cantidad de schedules para cada individuo # Calculamos particiones N_parts = 5 prct_train = .8 len_part_train = int(N * prct_train / 5) parts_train = [] parts_test = [] idx = np.arange(0, N) np.random.shuffle(idx) for i in range(N_parts - 1): idxs_train = idx[i * len_part_train:(i + 1) * len_part_train] parts_train.append(idxs_train) parts_test.append(list(set(idx) - set(idxs_train))) idxs_train = idx[(N_parts - 1) * len_part_train:] parts_train.append(idxs_train) parts_test.append(list(set(idx) - set(idxs_train))) # Inicializamos la clase SRGA, que preprocesa los datos si hace falta SRGA.init_class(lens, m_t, m_c, m_s, res=1000) mejores_fitnesses = [] part_alfa = [] part_phi = [] part_psi = [] part_umbral = [] #Usar particiones de entrenamiento print("ENTRENAMIENTO....") for i, part in tqdm(enumerate(parts_train)): # Definimos la funcion de fitness a utilizar (depende de algunos datos cargados) def f_fitness(vars): alfa0 = vars[0] umbral = vars[1] phi = vars[2:7] psi = vars[7:] srga = SRGA(alfa0, phi, psi, umbral) v_apts = np.zeros(n) scheds = np.random.choice(part, size=n) for i, s in enumerate(scheds): l = lens[s] if m_t[s, l - 1] < interrev: continue v_apts[i] = fitness(s, m_t[s, :l], m_acum_cs[s, -1], m_acum_ss[s, -1], srs=srga) return np.average(v_apts) # Definimos parametros a usar en el evolutivo evolutivo_kwargs = { 'N': 20, 'v_var': var_bits, 'probCrossOver': 0.9, 'probMutation': 0.2, 'f_deco': DecoDecimal, 'f_fitness': f_fitness, 'maxGens': 10, 'debugLvl': 90, } #Evolucionamos ga = GA(**evolutivo_kwargs) ga.Evolve(elitismo=True, brecha=.4) # Guardamos datos bestAggent = ga.bestAggent part_alfa.append(bestAggent[0]) part_umbral.append(bestAggent[1]) part_phi.append(bestAggent[2:7]) part_psi.append(bestAggent[7:]) mejores_fitnesses.append(ga.bestFitness) print(f"INFO PARTICION {i+1}:") print(f"MEDIA: {np.mean(ga.v_bestFitness)}") print(f"STD: {np.std(ga.v_bestFitness)}") print(f"MEDIANA: {np.median(ga.v_bestFitness)}") print(f"MAX: {np.max(ga.v_bestFitness)}") print(f"MIN: {np.min(ga.v_bestFitness)}\n\n") # Imprimimos los mejores fitnesses del entrenamiento print( f"Mejores fitnesses durante entrenamiento: {mejores_fitnesses}\n\n\n") #Particiones de testeo part_apts = [] part_apts_mean = [] part_apts_std = [] for i, part in tqdm(enumerate(parts_test)): srga = SRGA(part_alfa[i], part_phi[i], part_psi[i], part_umbral[i]) v_apts = np.zeros(n) scheds = np.random.choice(part, size=n) for i, s in enumerate(scheds): l = lens[s] if m_t[s, l - 1] < interrev: continue v_apts[i] = fitness(s, m_t[s, :l], m_acum_cs[s, -1], m_acum_ss[s, -1], srs=srga) part_apts.append(v_apts) part_apts_mean.append(np.mean(v_apts)) part_apts_std.append(np.std(v_apts))
#plt.plot(x,y) #initiate population population=[] for i in range(10): entity='' for j in range(17): entity=entity+str(np.random.randint(0,2)) # По идее, лепится строчная хромосома из 0, 1 и 2 population.append(entity) # По идее, в список популяции добавляется слепленная хромосома t=[] for i in range(1000): #selection value=utils.fitness(population,aimFunction) # вызывается фитнес-функция из utils, иниц-ся популяцией и целевой функцией population_new=selection(population,value) # (импортируется отбор) инициализируется новая популяция #crossover offspring =crossover(population_new,0.7) #(импортируется скрещивание) происходит скрещивание #mutation population=mutation(offspring,0.02) #(импортируется мутация) происходит мутация result=[] for j in range(len(population)): # перебирает все элементы популяции result.append(aimFunction(utils.decode(population[j]))) # формируется список результата ф-ии от декод. эл-в поп-ии t.append(max(result)) # в список t записывается макс. результат plt.plot(t) # Вероятно, строит график plt.axhline(max(y), linewidth=1, color='r')
import numpy as np from srs import SRGA,Uniforme from Evolutivo.evolutivo import GA from tqdm import tqdm from utils import fitness from SM2 import SM2 m_t = np.load('SRS/data/times.npy') m_c = np.load('SRS/data/correct.npy') m_s = np.load('SRS/data/seen.npy') m_d = np.load('SRS/data/lexemes_dificulty.npy') lens = np.load('SRS/data/len_schedule.npy') lens = lens.astype(int) SM2.init_class(lens, m_t, m_c, m_s, m_d) interrev = 1*24*3600 v_fitness = np.zeros(m_t.shape[0]) for i,sched in tqdm(enumerate(m_t)): sm2 = SM2() if m_t[i,lens[i]-1] < interrev: continue v_fitness[i] = fitness(i,m_t[i,:lens[i]],m_c[i,:lens[i]],m_s[i,:lens[i]],sm2) mean_fitness = np.mean(v_fitness) print(mean_fitness)
def run(target, cores, s=None): """ Genetic Hill Climbing Algorithm run here. Stores the image results in RESULTS directory, after every SAVE_PER_GEN generations . """ RESULTS = "results" # Make RESULTS directory, if not exists. if not os.path.exists(RESULTS): os.mkdir(RESULTS) # Logs file, in RESULTS directory. f = open(os.path.join(RESULTS, "logs.txt"), "a") generation = 1 INIT_GENES = 50 parent = Chromosome(target.size, INIT_GENES) # Load Save file from function parameter. if s is not None: generation = parent.load(jsonpickle.decode(s)) # First generation fitness. score = utils.fitness(parent.draw(), target) # Create thread pool for each core. p = multiprocessing.Pool(cores) # Frequency of saves and number of children # per generation of Genetic Hill Climbing Algorithm. SAVE_PER_GEN = 500 CHILDS_PER_GEN = 50 while True: f.write("Generation {0} Score {1}\n".format( generation, round(score, 5))) # Draw the image and save it. # Also save the logs. if generation % SAVE_PER_GEN == 0: print("Generation {0}\tScore {1}".format( generation, round(score, 5))) parent.draw().save(os.path.join( RESULTS, "{0}.png".format(generation))) save_file = open(os.path.join( RESULTS, "{0}.txt".format(generation)), "w") save_file.write(jsonpickle.encode(parent.save(generation))) save_file.close() generation += 1 # Mutate the current parent. try: results = utils.group_mutate(parent, CHILDS_PER_GEN - 1, p, target) except KeyboardInterrupt: print("Exiting program... Bye!") p.close() return # Children for the next generation. # Includes the current parent in case # bad mutation. new_score, new_children = map(list, zip(*results)) new_score.append(score) new_children.append(parent) # Choose the fittest child for next generation. fittest = min(zip(new_children, new_score), key=lambda x: x[1]) parent, score = fittest
def getSolution(self): return self.solution, fitness(self.solution), self.iteration
s = s[2:] return result if __name__ == '__main__': root = os.path.dirname(__file__) path = os.path.join(root, '../lab1/ngrams/english_trigrams.txt') trigrams = parse_ngrams(path) ngram_set = {3: trigrams} with open(os.path.join(root, 'input.txt')) as f: inputs = [s.strip() for s in f.readlines()] inpbytes = [hex2bytes(s) for s in inputs] for idx, line in enumerate(inpbytes): output = ['_'] * len(line) for l in inpbytes[:idx] + inpbytes[idx + 1:]: for charidx, (b1, b2) in enumerate(zip(line, l)): xored = b1 ^ b2 next_str = output[:] if xored in range(65, 91): next_str[charidx] = chr(xored) fitn1, fitn2 = (fitness(output, string.ascii_uppercase, ngram_set), fitness(next_str, string.ascii_uppercase, ngram_set)) if fitn2 >= fitn1: output = next_str print(''.join(output))
def main(): # Cargamos datos m_t = np.load('SRS/data/times.npy') m_c = np.load('SRS/data/correct.npy') m_s = np.load('SRS/data/seen.npy') m_d = np.load('SRS/data/lexemes_dificulty.npy') lens = np.load('SRS/data/len_schedule.npy') lens = lens.astype(int) N = m_t.shape[0] n = 10 # Reordenamos al azar idx = np.arange(N, dtype=int) np.random.shuffle(idx) m_t = m_t[idx][:n] m_c = m_c[idx][:n] m_s = m_s[idx][:n] lens = lens[idx][:n] # Creamos un SRS uniforme _uniforme = Uniforme(24 * 3600) # Datos relacionados a SRGA res = 1000 nvent = 5 phi = np.flip(np.linspace(0.10, 0.20, num=nvent)) psi = np.flip(-np.linspace(0.20, 0.40, num=nvent)) a = 0.4 #delta = 1 umbral = 0.9 sigma = 30 # en minutos # Creamos nuestro SRS deluxe, SRGA srga_kwargs = { 'alfa0': a, 'phi0': phi, 'psi0': psi, 'umbral': umbral, } # Inicializamos clase SRGA.init_class(lens, m_t, m_c, m_s, m_d, res=res, sigma=sigma) # Sigma en minutos srga = SRGA(**srga_kwargs) # Lo probamos contra todos los schedules v_apts = np.ones(n) * (-1) descartados = 0 umbral_fitness = 5 interrev = 1 * 24 * 3600 for i in tqdm(range(n)): l = lens[i] if m_t[i,l-1] < interrev: descartados += 1 continue v_apts[i] = fitness(i, m_t[i,:l], m_c[i,:l], m_s[i,:l], srs=srga) #v_apts[i] = fitness(m_t[i,:l], m_c[i,:l], m_s[i,:l], srs=srga, #return_revs=False, alfa=0.5, interrev=interrev) v_apts_sorted = np.sort(v_apts[v_apts>0]) print(f'10 peores: {v_apts_sorted[:10]}') print(f'10 mejores: {v_apts_sorted[-10:]}') print(f'Descartados: {descartados}') print(f'Menores a {umbral_fitness}: {np.sum(v_apts_sorted < umbral_fitness)}') print(f'Avg: {np.average(v_apts)}')
def fitness(self): return fitness(self.genes)
if r_ls >= P_LS: print("local search...") individual = crows[i].copy() individual = np.squeeze(np.asarray(individual)) crows[i] = PALS(num_fragments, individual, matrix) else: #print("the crow move to ramdon position", i) #the crow go to a random position #print('the crow go to random position', i, crows[i]) np.random.shuffle(crows[i]) #print('the crow went to random position', i, crows[i]) #print("memory[i]: ",i, memory[i]) #print("crows[i]: ",i, crows[i]) if fitness(matrix, crows[i]) > fitness(matrix, memory[i]): #print("the new position is better, updating memory") memory[i] = crows[i].copy() #print("memory[i]: ",i, memory[i]) #print("crows[i]: ",i, crows[i]) iter += 1 # get the best fitness best_fitness = 0 for i in range(N): fit = fitness(matrix, memory[i]) if fit > best_fitness: best_fitness = fit
def generateValuesToChart(self): values = [0] * 28 for g in self.genomes: v = fitness(g) values[v - 1] += 1 self.chartGen.addIteration(values, self.iteration)
#plt.plot(x,y) #initiate population population=[] for i in range(10): entity='' for j in range(17): entity=entity+str(np.random.randint(0,2)) population.append(entity) t=[] for i in range(1000): #selection value=utils.fitness(population,aimFunction) population_new=selection(population,value) #crossover offspring =crossover(population_new,0.7) #mutation population=mutation(offspring,0.02) result=[] for j in range(len(population)): result.append(aimFunction(utils.decode(population[j]))) t.append(max(result)) plt.plot(t) plt.axhline(max(y), linewidth=1, color='r')
from utils import fitness m_t = np.load('SRS/data/times.npy') m_c = np.load('SRS/data/correct.npy') m_s = np.load('SRS/data/seen.npy') lens = np.load('SRS/data/len_schedule.npy') lens = lens.astype(int) """ fitness(sched, ts, cs, ss, srs: SRS, return_revs=False, interrev=3600*6, alfa=0.4, k=1/(3600*24)): for cada uniforme t[i] creo el uniforme t[i] for cada Sched calculo el fitness del sched con el uniforme t[i] """ #t = [12,24,36,48,60,72,84,96] t = np.linspace(12, 180, 10) uniformes = [] v_fitness_tes = np.zeros(len(t)) interrev = 1 * 24 * 3600 for j, t_aux in tqdm(enumerate(t)): v_fitness = np.zeros(m_t.shape[0]) uniforme = Uniforme(t_aux * 3600) for i, sched in tqdm(enumerate(m_t)): if m_t[i, lens[i] - 1] < interrev: continue v_fitness[i] = fitness(i, m_t[i, :lens[i]], m_c[i, :lens[i]], m_s[i, :lens[i]], uniforme) v_fitness_tes[j] = np.mean(v_fitness) print(v_fitness_tes)
#print("new individual: ", individual) return individual if __name__ == "__main__": instance = 'x60189_4' matrix = np.genfromtxt(instance + '/matrix_conservative.csv', delimiter=',') #print(matrix.shape) num_fragments = matrix.shape[0] aleatory_solution = np.arange(num_fragments) np.random.shuffle(aleatory_solution) print("initial solution: ", aleatory_solution) sol = PALS(num_fragments, aleatory_solution, matrix) fitness_temp = fitness(matrix, sol) contigs_temp = consensus(matrix, sol) print("fitness: ", fitness_temp, "contig: ", contigs_temp) print("final solution: ", sol) #################################################### pruebas ######################################### num_test = 30.0 fitness_acum = best_fitness = contig_acum = 0.0 best_contig = 100 """ print("TESTING 30 ITEARTIONS...") for i in range(int(num_test)): aleatory_solution = np.arange(num_fragments) np.random.shuffle(aleatory_solution)