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 __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 __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 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 xtest_evaluate(self):
ind = ConvIndividual()
ind.randomInit()
print(ind)
fit = Fitness("data/mnist2d.train")
print("evaluating")
print(fit.evaluate(ind))
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 __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"))
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 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 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 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 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 __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 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 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 __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 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
"""
import numpy
import toolBox
from deap import tools
from deap import algorithms
from dbConnection import DB
from operator import itemgetter
from fitness import Fitness
from dbConnection import DB
# Variables
MUTATION_PROB = 0.5
CROSS_OVER_PROB = 1
NO_OF_GENERATION = 2
POPULATION_SIZE = 10
fitnessClass = Fitness()
databaseClass = DB()
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,
creator.create("Individual", Individual, fitness=creator.FitnessMax)
creator.create("Strategy", Strategy)
toolbox = base.Toolbox()
# Structure initializers
toolbox.register("individual", initIndStrategy, creator.Individual,
creator.Strategy)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
# use multiple processors
pool = multiprocessing.Pool(5)
toolbox.register("map", pool.map)
# register operators
fit = Fitness("data/" + trainset_name)
mut = MutationES()
cross = CrossoverES()
toolbox.register("evaluate", fit.evaluate)
toolbox.register("mate", cross.cxOnePoint)
toolbox.register("mutate", mut.mutate)
toolbox.register("select", tools.selTournament, tournsize=3)
def main(id, checkpoint_name=None):
# random.seed(64)
if checkpoint_name:
# A file name has been given, then load the data from the file
cp = pickle.load(open(checkpoint_name, "rb"))
signal.signal(signal.SIGINT, handler)
toolbox = base.Toolbox()
toolbox.register("attr_real", random.random)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.attr_real, IND_LEN)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
# toolbox.register("map", futures.map)
X = []
# Run the GA for each target image and target output.
for target_image in range(1):
print("Target image: {} ".format(target_image))
sys.stdout.flush()
fit = Fitness()
#Genetic operators
toolbox.register("evaluate", fit.evaluate)
#toolbox.register("mate", cxTwoPointCopy)
toolbox.register("mate", cxUniform)
toolbox.register("mutate",
tools.mutGaussian,
mu=0.0,
sigma=0.01,
indpb=0.05)
toolbox.register("select", tools.selTournament, tournsize=3)
#toolbox.register("select", tools.selRoulette)
X.append(mainGA())
def brute_force(cities):
a = itertools.permutations(cities)
list_values = []
for route in a:
list_values.append(Fitness(route).route_distance())
return min(list_values)
def rankStrategies(population):
fitnessResults = {}
u = Fitness()
for i in range(0, len(population)):
fitnessResults[i] = u.objFitness(population[i])
return sorted(fitnessResults.items(),key = operator.itemgetter(1), reverse = True)
def compute_fitness(self):
self.fitness = Fitness(self)
def __init__(self, app_list, pe_list):
self.random = SystemRandom()
self.app_list = app_list
self.num_app = len(app_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.sched_sim = SchedSimulator(app_list, pe_list, cpu_core_distribution)
self.fitness = Fitness(app_list, pe_list)
# variables for chromosome initialization with clustering
self._cluster_size = self.num_layer / self.num_pe
self.cluster_size = self._cluster_size
self.cluster_pe = self.random.randint(0, self.num_pe - 1)
self.cluster_iterator = 1
self.individual_index = 0
self.app_index = 0
# for debug
self.divide_iter = 0.5
self.inc_iter = 1
self.population = 64
self.population_index = 0
# Optimum fitness value is negative
creator.create("Fitness",
base.Fitness,
weights=(-1.0, ) * len(self.fitness.objs))
creator.create("Individual", list, fitness=creator.Fitness)
self.toolbox = base.Toolbox()
# XXX for using multi processors
self.toolbox.register("generate_processor", self.generate_processor)
self.toolbox.register("individual", tools.initRepeat,
creator.Individual,
self.toolbox.generate_processor, self.num_layer)
self.toolbox.register("population", tools.initRepeat, list,
self.toolbox.individual)
self.toolbox.register("mate", tools.cxUniform, indpb=0.1)
upList = [self.num_pe - 1] * self.num_layer
for start, end in zip(config.start_nodes_idx, config.end_nodes_idx):
upList[start -
1] = config.num_virtual_cpu - 1 # The first layer: only CPU
upList[end -
1] = config.num_virtual_cpu - 1 # The last layer: only CPU
self.toolbox.register("mutate",
tools.mutUniformInt,
low=0,
up=upList,
indpb=4 * len(app_list) / float(self.num_layer))
# self.toolbox.register("select", tools.selTournament, k=self.population, tournsize=4)
# self.toolbox.register("select", tools.selNSGA2, k=8)
self.toolbox.register("select", tools.selSPEA2, k=16)
# self.toolbox.register("select_best", tools.selBest, k=self.population / 16)
self.toolbox.register("select_random",
tools.selRandom,
k=self.population)
# self.toolbox.register("evaluate", self.sched_sim.do_simulation)
self.toolbox.register("evaluate", self.fitness.calculate_fitness)
while not has_found_best:
population = Population(pop_size=population_size)
if current_generation_count == 1:
# Initialize population for first generation using workout plans from file
starting_population = population.init_population()
else:
# Initialize population with next generation
starting_population = population.init_next_gen_population(
next_gen_population=next_gen_population)
# Reset next gen population list
next_gen_population = []
# score chromosomes in the population against fitness goal
scored_population = []
for chromosome in starting_population:
fitness = Fitness(chromosome=chromosome, fitness_goal=fitness_goal)
scored_chromosome = fitness.calculate_fitness()
scored_population.append(scored_chromosome)
# Select parents for offspring generation
for ch in range(0, scored_population.__len__(), 1):
# perform parent selection from scored population
selection = Selection(population=scored_population)
parents = selection.select()
# perform crossover based on 50% probability
crossover_prob = random.choice([True, False])
crossover = Crossover(parents,
crossover_probability=crossover_prob)
offspring = crossover.perform_crossover()
# Structure initializers
toolbox.register("individual", initIndividual, creator.Individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
# use multiple processors or GPU
if config.global_config["device"]["device_type"] == "CPU":
n_cpus = config.global_config["device"]["n_cpus"]
pool = multiprocessing.Pool(n_cpus)
toolbox.register("map", pool.map)
logging.info(f"Running on {n_cpus} CPUs")
else:
logging.info(f"Running on GPU.")
# register operators
fit = Fitness(**config.global_config["dataset"])
mut = MutationConv() if use_conv_layers else Mutation()
cross = CrossoverConv() if use_conv_layers else Crossover()
toolbox.register("eval_batch", fit.evaluate_batch)
toolbox.register("evaluate", fit.evaluate)
toolbox.register("mate", cross.cxOnePoint)
toolbox.register("mutate", mut.mutate)
if nsga_number == 3:
ref_points = tools.uniform_reference_points(2, 12)
toolbox.register("select", tools.selNSGA3, ref_points=ref_points)
elif nsga_number == 2:
# nsgaII - deap implementation
toolbox.register("select", tools.selNSGA2)
elif nsga_number == 1:
# stepan's version of nsga
