def popular(self):
self.populacao = []
for c in range(0, self.tam_populacao):
cromo = Cromossomo(self.QTD_ALELOS)
for a in range(0, len(cromo.alelos)):
cromo.alelos[a] = random.randrange(self.inicio, self.fim + 1)
cromo.aptidao = self.calcAptidao(cromo.alelos[0], cromo.alelos[1])
self.populacao.append(cromo)
def crossover(self, p1: object, p2: object) -> object:
'''Faz cruzamento (crossover) unindo a primeira metade de genes do primeiro progenitor
com a segunda meteade de genes do segundo progenitor'''
half = int(p1.compositionSize / 2)
new_composition = p1.composition[:half] + p2.composition[half:]
c = Cromossomo()
c.composition = new_composition
c.evaluate_fitness() # atualiza características do cromossomo
return c
def cruzaDois(self, cromossomoA, cromossomoB):
'''
Realiza o Cruzamento – Ponto Duplo
'''
novoCromossomoA = cromossomoA.cromossomo[:2] + \
cromossomoB.cromossomo[2:6] + cromossomoA.cromossomo[6:]
novoCromossomoB = cromossomoB.cromossomo[:2] + \
cromossomoA.cromossomo[2:6] + cromossomoB.cromossomo[6:]
return [Cromossomo(novoCromossomoA), Cromossomo(novoCromossomoB)]
def cruzar(self, selecao):
selecao = self.selecionar()
filhos = []
for i in range(0, int(len(selecao) / 2)):
(pai, pai2) = (self.populacao[selecao[2 * i]],
self.populacao[selecao[2 * i + 1]])
# Sorteia um número de 0 a 1 com duas casas decimais
num = random.randrange(0, 100) / 100
if num <= self.tax_cruzamento:
# Porcentagem do cromossomo dos pais que será utilizada no cruzamento
alfa_cruzamento = random.randrange(0, 100) / 100
# Se for menor que a taxa de cruzamento, faz o c/home/aluno/Downloadsruzamento aritmético
qtd_alelos = len(pai.alelos)
# Cria os cromossomos
f1 = Cromossomo(qtd_alelos)
f2 = Cromossomo(qtd_alelos)
f1.alelos = alfa_cruzamento * pai.alelos + (
1 - alfa_cruzamento) * pai2.alelos
f2.alelos = (1 - alfa_cruzamento
) * pai.alelos + alfa_cruzamento * pai2.alelos
f1.aptidao = self.calcAptidao(f1.alelos[0], f1.alelos[1])
f2.aptidao = self.calcAptidao(f2.alelos[0], f2.alelos[1])
# Adiciona a lista de filhos
filhos.append(f1)
filhos.append(f2)
else:
# Senão apenas propaga os pais
filhos.append(pai)
filhos.append(pai2)
return filhos
def inicializarPopulacao(self, tamanho_populacao_inicial):
individuoDefault = '0000000000000000000000000000'
self.cromossomos.append(Cromossomo(individuoDefault, self.blue_print))
for i in range(0, (tamanho_populacao_inicial - 1)):
novo = self.gerarUmIndividuo()
self.cromossomos.append(novo)
def segunda_avaliacao(self, cromo: Cromossomo):
contador = 0
for c in cromo.dna:
if c == 0:
contador += 1
cromo.aptidao_cars = contador
def mutacao(self, cromossomo):
rand = random.randint(0, 27)
individuo = cromossomo
m = int(individuo[rand])
if (m == 0):
list1 = list(individuo)
list1[rand] = '1'
str1 = ''.join(list1)
individuo = str1
else:
list1 = list(individuo)
list1[rand] = '0'
str1 = ''.join(list1)
individuo = str1
m = int(individuo[rand])
if (m == 0):
list1 = list(individuo)
list1[rand] = '1'
str1 = ''.join(list1)
individuo = str1
else:
list1 = list(individuo)
list1[rand] = '0'
str1 = ''.join(list1)
individuo = str1
return Cromossomo(individuo)
def primeira_avaliacao(self, cromo: Cromossomo):
distancia = 0
for i in range(len(cromo.dna) - 1):
atual = cromo.dna[i + 1]
anterior = cromo.dna[i]
distancia += self.distancia_c[anterior][atual] # TODO: checar
cromo.aptidao_dist = distancia
def gerarUmIndividuo(self):
novo = ''
criterion = random.randint(0, 1)
splitter = random.randint(0, 1)
novo += str(criterion) + str(splitter)
max_depth_bit1 = random.randint(0, 1)
max_depth_bit2 = random.randint(0, 1)
max_depth_bit3 = random.randint(0, 1)
max_depth_bit4 = random.randint(0, 1)
max_depth_bit5 = random.randint(0, 1)
max_depth_bit6 = random.randint(0, 1)
novo += str(max_depth_bit1) + str(max_depth_bit2) + str(max_depth_bit3) + \
str(max_depth_bit4) + str(max_depth_bit5) + str(max_depth_bit6)
min_samples_split_bit1 = random.randint(0, 1)
min_samples_split_bit2 = random.randint(0, 1)
min_samples_split_bit3 = random.randint(0, 1)
min_samples_split_bit4 = random.randint(0, 1)
min_samples_split_bit5 = random.randint(0, 1)
min_samples_split_bit6 = random.randint(0, 1)
min_samples_split_bit7 = random.randint(0, 1)
min_samples_split_bit8 = random.randint(0, 1)
novo += str(min_samples_split_bit1) + str(min_samples_split_bit2) + str(min_samples_split_bit3) + str(min_samples_split_bit4) + str(min_samples_split_bit5) + \
str(min_samples_split_bit6) + str(min_samples_split_bit7) + str(min_samples_split_bit8)
min_samples_leaf_bit1 = random.randint(0, 1)
min_samples_leaf_bit2 = random.randint(0, 1)
min_samples_leaf_bit3 = random.randint(0, 1)
min_samples_leaf_bit4 = random.randint(0, 1)
min_samples_leaf_bit5 = random.randint(0, 1)
min_samples_leaf_bit6 = random.randint(0, 1)
min_samples_leaf_bit7 = random.randint(0, 1)
min_samples_leaf_bit8 = random.randint(0, 1)
novo += str(min_samples_leaf_bit1) + str(min_samples_leaf_bit2) + str(min_samples_leaf_bit3) + str(min_samples_leaf_bit4) + str(min_samples_leaf_bit5) + \
str(min_samples_leaf_bit6) + str(min_samples_leaf_bit7) + str(min_samples_leaf_bit8)
min_weight_fraction_leaf_bit1 = random.randint(0, 1)
min_weight_fraction_leaf_bit2 = random.randint(0, 1)
min_weight_fraction_leaf_bit3 = random.randint(0, 1)
novo += str(min_weight_fraction_leaf_bit1) + \
str(min_weight_fraction_leaf_bit2) + \
str(min_weight_fraction_leaf_bit3)
presort = random.randint(0, 1)
novo += str(presort)
return Cromossomo(novo, self.blue_print)
def generate(self, ambiente):
tamanho = len(ambiente.pesos)
for i in range(self.limit):
# gera um array de 1 a N de forma aleatoria, onde o primeiro e o ultimo elemento são 0's
new_dna = list(range(1, tamanho))
random.shuffle(new_dna)
new_dna.insert(0, 0)
new_dna.insert(len(new_dna), 0)
self.population.append(Cromossomo(new_dna, 0, 0))
def bruteForce():
compositionSize = composition_size()
limit = pow(2, compositionSize) - 1
best = Cromossomo()
for i in range(limit):
print(f"Brute Force limit {i}", end='\r')
new_composition = list(bin(i)[2:].zfill(compositionSize))
new_composition = map(lambda x: int(x), new_composition)
new_composition = list(new_composition)
c = Cromossomo()
c.composition = new_composition
c.evaluate_fitness()
if (c.fitness):
if (c.value > best.value):
best = c
elif (c.value == best.value) and (c.weight <= best.weight):
best = c
print("\nKnapsack Problem - Brute Force")
print("A melhor resposta encontrada foi:")
print(f"composition: {best.composition}")
print(f"value: {best.value}")
print(f"weight: {best.weight}")
return best
def cruzamento(self, selecionados: list):
r = random.randint(0, self.tam_cromossomo)
s11, s12 = selecionados[0].separar_no_indice(r)
s21, s22 = selecionados[1].separar_no_indice(r)
filho_1 = s11 + s22
filho_2 = s21 + s12
c1 = Cromossomo(filho_1, self.tam_cadeia)
c2 = Cromossomo(filho_2, self.tam_cadeia)
c1.mutacao_de_gap(taxa=0.2)
c2.mutacao_de_gap(taxa=0.2)
self.populacao.append(c1)
self.populacao.append(c2)
self.avaliar_populacao()
def crossover_pmx(population):
nova_pop = []
for i in range(len(population)):
for j in range(len(population)):
if i == j:
continue
ponto_de_corte = random.randint(0, len(population[i].dna))
new_dna = []
for k in range(min(len(population[i].dna),
len(population[j].dna))):
if k <= ponto_de_corte:
new_dna.append(population[i].dna[k])
else:
new_dna.append(population[j].dna[k])
nova_pop.append(Cromossomo(new_dna, 0, 0))
return population
def crossover(populacao):
metade_da_metade = 5
for i in range(0, metade_da_metade): #Itera cinco vezes gerando 10 filhos
pai = populacao[i] #Para o pai, pega-se o primeiro(melhor) cromossomo
mae = populacao[randrange(
0, 10)] #Para o outro pai, pega-se um cromossomo aleartório
filho1 = Cromossomo()
filho1.genes = pai.crossover(mae) #Realiza o crossover
filho2 = Cromossomo()
filho2.genes = mae.crossover(pai) #Realiza o crossover
populacao[i + 10] = filho1 #Atribui os filhos
populacao[i + 11] = filho2
return populacao
def bornAnIndividual(self, listaCromossomoNovo):
novoCromossomo = []
novoIndividuo = ''
for i in range(28):
epvi = (self.taxa_aprendizado_global * self.blue_print[i]) + (
(1 - self.taxa_aprendizado_global) * listaCromossomoNovo[i])
if (epvi < self.taxa_diversidade):
novoCromossomo.append(self.taxa_diversidade)
elif (epvi > (1 - self.taxa_diversidade)):
novoCromossomo.append(1 - self.taxa_diversidade)
else:
novoCromossomo.append(round(epvi, 2))
valor = self.lancarMoeda()
if (valor <= novoCromossomo[i]):
novoIndividuo += '1'
else:
novoIndividuo += '0'
cromossomo = Cromossomo(novoIndividuo, novoCromossomo)
return cromossomo
def selecao_roleta(population, limit):
individuos = []
sum = 0
for cromo in population:
sum += cromo.aptidao_dist / cromo.aptidao_cars
for i in range(limit):
aux = 0
numero_aleatorio = random.randint(0, math.floor(sum))
for j in range(len(population)):
aux += population[j].aptidao_dist / population[j].aptidao_cars
if j == 0:
continue
if aux > numero_aleatorio:
pop = population[j - 1]
individuos.append(
Cromossomo(pop.dna, pop.aptidao_dist, pop.aptidao_cars,
pop.qt_restricoes))
break
return individuos
def __init__(self, populacao=[], tam=10):
'''Inicializa população com cromossomos randomicos ou com uma especificada'''
if not populacao:
self.populacao = [Cromossomo() for _ in range(tam)]
else:
self.populacao = populacao
def gerar_populacao(self, dataset: list, max_len: int):
self.populacao = []
self.tam_cadeia = max_len
for i in range(self.tam_populacao):
self.populacao.append(Cromossomo(dataset, self.tam_cadeia))
def initialize(self):
'''inicializa a população de cromossomos com valores aleatórios'''
for i in range(self.size):
cromossomo = Cromossomo()
cromossomo.initialize()
self.cromossomos.append(cromossomo)
def arruma_cromo(self, cromo: Cromossomo):
cromo.aptidao_dist = 0
cromo.aptidao_cars = 0
cromo.qt_restricoes = 0
container = [[]]
j = 0
sum = 0
for i in range(len(cromo.dna)):
sum += self.pesos[cromo.dna[i]]
if sum > self.capacidade_veiculos:
j += 1
container.append([])
sum = self.pesos[cromo.dna[i]]
elif cromo.dna[i] == 0:
if i > 0:
if cromo.dna[i - 1] != 0:
j += 1
container.append([])
else:
container.append([])
sum = self.pesos[0]
if cromo.dna[i] != 0:
container[j].append(cromo.dna[i])
new_dna = []
aux_qt = copy.deepcopy(self.quantidade_veiculos)
for i in range(len(container)):
for j in range(len(container[i])):
new_dna.append(container[i][j])
if len(new_dna) > 1:
if new_dna[len(new_dna) - 1] != 0 and aux_qt > 1:
new_dna.append(0)
aux_qt -= 1
elif new_dna[len(new_dna) - 1] != 0:
new_dna.append(0)
cromo.aumenta_restricao()
else:
new_dna.append(0)
cromo.dna = new_dna
cromo_set = set()
for i in range(len(cromo.dna)):
if cromo.dna[i] in cromo_set and cromo.dna[i] != 0:
cromo.dna.remove(i)
continue
cromo_set.add(cromo.dna[i])
sum = 0
for i in range(len(self.pesos)):
if i not in cromo_set:
sum += self.pesos[i]
if sum > self.capacidade_veiculos:
cromo.dna.append(0)
sum = self.pesos[i]
cromo.dna.append(i)
if cromo.dna[0] != 0:
cromo.dna.insert(0, 0)
if cromo.dna[len(cromo.dna) - 1] != 0:
cromo.dna.append(0)
def inicializar_populacao(self):
for i in range(self.tam_populacao):
self.populacao.append(Cromossomo(100))
for cromossomo in self.populacao: cromossomo.inicializar()