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)
