Análise do Gerador de Mapas de jogos Match-Three

class QuebraDoceGenerator: """ Esta classe é utilizada para manter as informações necessárias pelo Algoritmo Genético e para gerar mapas para o jogo. """ def __init__(self, pop_size=25, n_kids=10, crossover_rate=0.75, mutation_rate=0.01): """ Inicializa o gerador, passando informações necessárias. pop_size -> tamanho da população n_kids -> quantidade de filhos criados crossover_rate -> taxa de cruzamento (depende do método utilizado) mutation_rate -> taxa de mutação As variáveis de n_simulations e n_moves são usadas na simulação de uma fase e *NÃO DEVEM* ser modificadas. O valor de bias e best_distance são usados no interior do processo e não precisa ser modificado. """ self.pop_size = pop_size self.crossover_rate = crossover_rate self.mutation_rate = mutation_rate self.n_simulations = 15 self.n_moves = 1 self.bias = 0.00 self.best_distance = 1.0 self.n_kids = n_kids def _evaluate_content(self, content): """ Avalia um conteúdo gerado, retornando o seu desempenho médio. (calculado por um bot) """ bot = qd_bot.QuebraDoceAI(string=content) resultado = bot.do_playouts(n=self.n_simulations, n_moves=self.n_moves, info=False) return round(resultado, 3) def generate_moves(self): """ Gera uma quantidade de movimentos pro mapa. Este valor varia de 5 até 30. """ return random.randint(5, 30) def generate_types(self): """ Gera a quantidade de peças diferentes estarão no mapa. Este valor varia de 4 até 6. """ return random.randint(4, 6) def generate_points(self, types): """ Gera a quantidade de pontos necessário para completar a fase. Quanto mais peças diferentes, menor é a pontuação criada. (pois fases com mais peças é mais dificil de fazer combinações) """ if self.points: x = abs(types - 6) return random.randint(0, 100000 + x*20000) else: return 0 def _random_level(self): """ Gera um mapa de forma aleatória. """ # String contendo o mapa string = '' # Quantidade de movimentos moves = self.generate_moves() # Quantidade de tipos types = self.generate_types() # Pontuação necessária points = self.generate_points(types) # Adiciona essa informação na string string += str(moves) + "," string += str(points) + "," string += str(types) + "\n" # Gera o formato do mapa pieces = None for i in range(9): # O mapa é gerado de baixo pra cima, # por isso não pode haver peças de objetivo na ultima linha. # Se não for a ultima linha, pode utilizar todas as peças if i > 0: pieces = self.pieces else: pieces = self.first_pieces # Percorre todas as posições for j in range(9): # Gera a peça p = random.choice(pieces) string += str(p) # Se não for a ultima peça, adiciona a ',' if j != 8: string += "," # Adiciona a nova linha string += "\n" # Retorna o mapa return string def _select(self, pop): """ pop -> população completa Método que seleciona o 2 melhores mapas da população. (avaliando o que tiver a menor distância do objetivo) """ pop.sort(key=lambda data:data['distance']) return pop[:2] def _standard_crossover(self, parents): """ parents -> [p1, p2] Método de cruzamento padrão. caso passe pela taxa de cruzamento, escolhe aleatoriamente uma informação de um dos pais (pra cada posição). Caso contrário, retorna o que tiver a menor distância. """ child = None # Se estiver no crossover_rate, une os dois if random.uniform(0.0, 1.0) <= self.crossover_rate: string = '' p1 = parents[0]['level'] p2 = parents[1]['level'] p1_lines = p1.split("\n") p2_lines = p2.split("\n") line_1 = p1_lines[0].split(",") line_2 = p2_lines[0].split(",") for i in range(len(line_1)): x = int(line_1[i]) y = int(line_2[i]) value = random.choice([x, y]) string += str(value) if i != 2: string += "," string += "\n" for i in range(1, 10): line_1 = p1_lines[i] line_2 = p2_lines[i] for j in range(len(line_1)): if line_1[j] != ",": x, y = int(line_1[j]), int(line_2[j]) value = random.choice([x, y]) string += str(value) else: string += "," string += "\n" child = string # Caso não rolou crossover, retorna o melhor else: child = min(parents, key=lambda x:x['distance']) child = child['level'] # Retorna a lista com a criança return [ { 'level': child, 'evaluate': 0.0, 'distance': 1.0, } ] def _mutate(self, child, distance): """ child -> filho a ser mutado distance -> distância do filho pro objetivo Método de mutação. Aplica mutação ao filho, utilizando a taxa de mutação definida junto da distância. """ string = '' # calcula o mutation rate # Quanto mais longe do resultado esperando, mais mutação mutation_rate = self.mutation_rate + (distance/10) # Divide as linhas lines = child.split("\n") # Divide as informações dos cabeçalhos info = lines[0].split(",") # Pega movimentos moves = 0 if random.uniform(0.0, 1.0) <= mutation_rate: moves = self.generate_moves() else: moves = int(info[0]) # Pega Tipos types = 0 if random.uniform(0.0, 1.0) <= mutation_rate: types = self.generate_types() else: types = int(info[2]) # Pega pontos points = 0 if random.uniform(0.0, 1.0) <= mutation_rate: points = self.generate_points(types) else: points = int(info[1]) # Escreve o cabeçalho string += str(moves) + "," string += str(points) + "," string += str(types) + "\n" # Escreve o mapa ps = None for i in range(1, 10): line = lines[i] pieces = line.split(",") # Se for depois da primeira linha if i > 1: ps = self.pieces else: ps = self.first_pieces # Percorre uma linha for j in range(len(pieces)): p = 0 if random.uniform(0.0, 1.0) <= mutation_rate: p = random.choice(ps) else: p = pieces[j] string += str(p) if j != 8: string += "," string += "\n" # Retorna o mapa return string def _standard_selection(self, pop): """ pop -> população Método de Seleção Padrão. Seleciona uma dupla de indivíduos. """ # Decide o limite dos melhores limit = 10 if self.pop_size < limit: limit = self.pop_size # Pega os melhores pop.sort(key=lambda x: x['distance']) best = pop[:limit] best = copy.deepcopy(best) # Escolhe aleatoriamente os melhores p1 = random.choice(best) p2 = random.choice(best) return [p1,p2] def _create_kids(self, pop): """ pop -> população Cria os filhos desta geração. Utiliza os métodos de Seleção, Crossover e mutação para gerar n_kids filhos. """ # Usado no método de seleção estocastico global valor_segmento valor_segmento = None # Cria os N Filhos kids = [] while len(kids) < self.n_kids: # Escolhe aleatoriamente os melhores parents = self._selection_method(pop) # Crossover dos pais p_kids = self._crossover_method(parents) # Adiciona o valor médio de distância, # para usar na mutação value = 0 for p in parents: value += p['distance'] value /= len(parents) # Faz a mutação nos filhos gerados pelo crossover for p_kid in p_kids: # Muta a criança str_kid = self._mutate(p_kid['level'], value) # Adiciona a lista de filhos data = { 'level': str_kid, 'evaluate': 0.0, 'distance': 1.0 } kids.append(data) # Retorna os filhos return kids def _kill_bad(self, pop, kids, target): """ pop -> população kids -> filhos gerados target -> objetivo a ser alcançado Une a população com os filhos e retorna os pop_size melhores. """ # Avalia todos os filhos criados for k in kids: k['evaluate'] = self._evaluate_content(k['level']) k['distance'] = abs(k['evaluate'] - target) pop.append(k) # Retorna apenas os pop_size melhores pop.sort(key=lambda data:data['distance']) pop = pop[:self.pop_size] pop = copy.deepcopy(pop) return pop def generate_level(self, target, n_generations=100, points=True, blocks=True, canes=True, s_method=None, c_method=None): """ target -> objetivo a ser alcançado n_generations -> número de gerações points -> o mapa terá modo de pontuação? blocks -> o mapa terá modo de bloqueios? canes -> o mapa terá modo de objetivo? s_method -> método de seleção utilizado c_method -> método de crossover utilizado Gera um mapa do jogo com o desempenho médio desejado e com os objetivos inseridos. """ # Usado para verificar se o código é inválido invalid = False start = time.time() # Confere os targets invalidos if target > 1.0: invalid = True elif target < 0.0: invalid = True elif target < self.bias: invalid = True elif (not points) and (not blocks) and (not canes): invalid = True # Não é possivel gerar if invalid: print('deu ruim') return False # Adiciona o método de seleção if s_method is None: self._selection_method = self._standard_selection else: self._selection_method = s_method # Adiciona o método de crossover if c_method is None: self._crossover_method = self._standard_crossover else: self._crossover_method = c_method # Inicializa as peças self.first_pieces = [0, 1] self.pieces = [0, 1] # Inicializa os modos self.points = points self.blocks = blocks self.canes = canes # Se for o modo de bloqueio, adiciona essas # peças possíveis if blocks: self.first_pieces.append(2) self.pieces.append(2) # Se for o modo objetivo, adiciona essa # peça if canes: self.first_pieces.append(3) # Percorre tantas gerações target_level = None found = False # Gera uma população inicial pop = [] for i in range(self.pop_size): l = self._random_level() val = self._evaluate_content(l) d = abs(val - target) data = { 'level': l, 'evaluate': val, 'distance': d} pop.append(data) # Inicializa o bias self.bias = 0.001 # Inicializa a melhor distância self.best_distance = 1.0 # Verifica se encontrou um resultado finished = False # Percorre a geração for gen in range(n_generations): # Recebe a melhor população best_pop = self._select(pop) best_pop = copy.deepcopy(best_pop) # Pega a melhor distância if best_pop[0]['distance'] < self.best_distance: self.best_distance = best_pop[0]['distance'] # Informações da geração print('\r' + ' '*100, end='') print('\rGERAÇÃO [{0}/{1}] -> MELHOR = [{2:.3f}, {3:.3f}]'.format( gen+1, n_generations, best_pop[0]['evaluate'], best_pop[0]['distance'] ), end='' ) # Se é melhor que o bias target_level = best_pop[0] if best_pop[0]['distance'] <= self.bias: print(" ENCONTRADO!", end='') finished = True break # Cria novos filhos e elimina os piores kids = self._create_kids(pop) pop = self._kill_bad(pop, kids, target) else: print(' NÃO ENCONTRADO!', end='') # Tempo demorado end = time.time() - start # Retorna os resultados return { 'tempo': end, 'gen': gen + 1, 'completo': int(finished), }

# Usado para saber o valor do segmento # na amostragem estocastica uniforme global valor_segmento valor_segmento = None ### - Juan Burtet - ### - COMPLETO def amostragem_estocastica_uniforme(populacao): """ Todos os indivíduos são mapeados para segmentos contíguos de uma linha. O tamanho de cada segmento é proporcional ao valor da avaliação do indivíduo que está sendo mapeado. Normalizamos os tamanhos (soma igual a 1). Sorteamos um número i entre 0 e 1/n. Atribuímos n ponteiros que passam a apontar para segmentos de reta, nas posições i + passos de 1/n. """ # Variável utilizada pro segmento global valor_segmento # embaralha a população populacao = random.sample(populacao, len(populacao)) # Normalizando os valores das distâncias (soma igual a 1) tamanhos = [abs(1 - p['distance']) for p in populacao] tamanhos = [t/sum(tamanhos) for t in tamanhos] # Adiciona os intervalos dos segmentos de reta segmentos = [0] contador = 0 for i in range(len(tamanhos)-1): contador += tamanhos[i] segmentos.append(contador) # Sorteio do número if valor_segmento is None: valor_segmento = random.uniform(0, 1/len(populacao)) else: valor_segmento += 1/len(populacao) # Usado para recuperar o indice da população def index_of_pop(value): for i in range(len(segmentos)-1): if segmentos[i] <= value < segmentos[i+1]: return i else: return len(segmentos) - 1 # Lista de selecionados selecionados = [] # Adiciona o primeiro filho if valor_segmento >= 1: valor_segmento -= 1 selecionados.append(populacao[index_of_pop(valor_segmento)]) # Adiciona o segundo filho valor_segmento += 1/len(populacao) if valor_segmento >= 1: valor_segmento -= 1 selecionados.append(populacao[index_of_pop(valor_segmento)]) # retorna os selecionados selecionados = copy.deepcopy(selecionados) return selecionados ### - Giorgio Rossa - ### - COMPLETO def roleta_viciada(populacao): """ O método da roleta viciada é um método de seleção de indivíduos com base na sua avaliação, porém de forma que exista a possibilidade de indivíduos piores também serem selecionados. Neste método, cada indivíduo recebe uma probabilidade de ser escolhido de acordo com sua avaliação, de forma que a soma de todas as probabilidades atinja 100%. A implementação da roleta consiste em somar todos os valores das avaliações e sortear um número entre 0 e a soma total. Após isso, procuramos na lista de indivíduos qual o indivíduo que está com aquela faixa de representação. """ # Tamanho total das distâncias, # para fazer a roleta somaTotal = 0 for i in populacao: somaTotal += (1 - i['distance']) # Define os valores para cada roleta p1 = random.uniform(0, somaTotal) p2 = random.uniform(0, somaTotal) # Faz a roleta para cada um dos selecionados selecionados = [] for p in [p1,p2]: # Inicializa na primeira posição index = 0 aux = (1 - populacao[0]['distance']) # Percorre até encontrar o valor na roleta while aux < p: index += 1 aux += (1 - populacao[index]['distance']) # adiciona a lista de selecionados selecionados.append(populacao[index]) # Faz uma copia e retorna selecionados = copy.deepcopy(selecionados) return selecionados ### - Matheus Freitag - ### - COMPLETO def selecao_truncada(populacao): """ Apenas os melhores x% da população poderão ser escolhidos como pais da próxima geração. O valor x é um parâmetro do algoritmo, que pode variar de 1% a 100%. Os valores mais usuais para x são aqueles na faixa [10%-50%]. Os indivíduos são ordenados de forma decrescente de acordo com sua avaliação. Somente aqueles cujas posições estiverem entre 1 e a posição de corte poderão participar da seleção. """ # Ordena pela avaliação populacao.sort(key=lambda x: x['distance']) # Pega aleatoriamente os indices dos melhores melhores = round(len(populacao) * 0.4) index1 = random.randint(0, melhores) index2 = random.randint(0, melhores) # seleciona os 2 pais p1 = copy.deepcopy(populacao[index1]) p2 = copy.deepcopy(populacao[index2]) # retorna os selecionados selecionados = [p1,p2] return selecionados ### - Alexandre Bender - ### - COMPLETO def selecao_torneio(population): """ Consiste em receber um parâmetro n que denota o tamanho do torneio e gerar torneios amostrando uma quantidade n de indivíduos da população. Esse método retorna o indivíduo mais apto do torneio instanciado. Quanto maior o torneio, maior a dominância do indivíduo com maior avaliação da população. Se for instanciado o torneio com o tamanho da população, necessariamente esse torneio será vencido pelo melhor indivíduo. Outro ponto relevante é que dificilmente o pior indivíduo será selecionado (somente no caso de realizar um torneio de tamanho n = 1 e o valor amostrado coincidir com o pior indivíduo). Para mitigar isso, dando mais representatividade aos indivíduos com avaliações piores, podem ser usados valores de n menores. """ def create_tournament(population, size): sample = random.sample(list(enumerate(population)), size) indexes = [] participants = [] for idx, val in sample: indexes.append(idx) participants.append(val) best_distance = participants[0]['distance'] winner = participants[0] for individual in participants: if individual['distance'] < best_distance: best_distance = individual['distance'] winner = individual winner = copy.deepcopy(winner) return winner size = round(len(population) * 0.16) father_a = create_tournament(population, size) father_b = create_tournament(population, size) return [father_a, father_b]

### - Juan Burtet - ### - COMPLETO def crossover_flat(pais): """ Estabelecer um intervalo fechado para cada par de valores no cromossomo, do menor valor armazenado até o maior. Escolher um valor aleatório dentro deste intervalo. """ assert len(pais) == 2 # Recupera o mapa dos pais p1 = pais[0]['level'].split('\n') p2 = pais[1]['level'].split('\n') # Lista dos filhos child1 = [] child2 = [] # Percorre todas as linhas do mapa for i, (row_p1, row_p2) in enumerate(zip(p1, p2)): if i >= 10: break # Lista da linha do mapa dos filhos row_c1 = [] row_c2 = [] # Percorre as colunas das linhas dos pais for v_p1, v_p2 in zip(row_p1.split(','), row_p2.split(',')): # Transforma em inteiro e garante que o primeiro # seja menor que o segundo v_p1, v_p2 = int(v_p1), int(v_p2) v_p1, v_p2 = min(v_p1, v_p2), max(v_p1, v_p2) # Adiciona o valor dos filhos que seja # o intervalo do gene dos pais row_c1.append(str(random.randint(v_p1, v_p2))) row_c2.append(str(random.randint(v_p1, v_p2))) # Adiciona a linha dos filhos em string child1.append(','.join(row_c1)) child2.append(','.join(row_c2)) # Transforma os filhos em strings child1 = '\n'.join(child1) child2 = '\n'.join(child2) # retorna os filhos return [ {'level': child1, 'evaluate': 0.0, 'distance': 1.0,}, {'level': child2, 'evaluate': 0.0, 'distance': 1.0,}, ] ### - Giorgio Rossa - ### - COMPLETO def crossover_simples(pais): """ O método de crossover simples consiste em escolher um ponto de corte nos pais, o primeiro filho recebe os valores à esquerda do corte do primeiro pai concatenados com os valores da direita do segundo pai, e o segundo filho recebe o inverso. """ # sorteia uma porcentagem para o corte corte = random.random() # 0 até 1 child1 = '' child2 = '' p1 = pais[0]['level'] p2 = pais[1]['level'] p1_lines = p1.split("\n") p2_lines = p2.split("\n") line_1 = p1_lines[0].split(",") # line 2 é literamente a segunda linha nesse caso, para utilizar o tamanho no corte line_2 = p1_lines[1].split(",") # converte % de corte para o corte da primeira linha corte1 = round(len(line_1)*corte) # se pegar 0 ou nMax bota +1 ou -1 pra ficar 1 tamanho minimo de corte corte1 = 1 if corte1 == 0 else corte1 corte1 = len(line_1)-1 if corte1 == len(line_1) else corte1 # converte para o corte das linhas normais corte2 = round(len(line_2)*corte) corte2 = 1 if corte2 == 0 else corte2 corte2 = len(line_2)-1 if corte2 == len(line_2) else corte2 # line 2 é a linha do segundo pai a partir de agora line_2 = p2_lines[0].split(",") # faz a primeira linha for i in range(len(line_1)): if i < corte1: child1 += line_1[i] child2 += line_2[i] else: child1 += line_2[i] child2 += line_1[i] if i != 2: child1 += "," child2 += "," child1 += "\n" child2 += "\n" # corta linha a linha for i in range(1, 10): line_1 = p1_lines[i] line_2 = p2_lines[i] # k é um contador para que as virgulas nao sejam contadas, já que no corte2 é a quantidade de elementos k = 0 for j in range(len(line_1)): if line_1[j] != ",": if k < corte2: child1 += line_1[j] child2 += line_2[j] else: child1 += line_2[j] child2 += line_1[j] k+= 1 else: child1 += "," child2 += "," child1 += "\n" child2 += "\n" return [ {'level': child1, 'evaluate': 0.0, 'distance': 1.0,}, {'level': child2, 'evaluate': 0.0, 'distance': 1.0,}, ] ### - Matheus Freitag - ### - COMPLETO def crossover_dois_pontos(pais): """ São definidos dois pontos em comum em um dos pais, e os mesmos pontos são definidos no outro pai. Este método permite que diferentes pontos pré-definidos sejam embaralhados entre os dois pais, para que os filhos recebam uma maior variedade genética. """ assert len(pais) == 2 # Precisa ter exatamente 2 pais filhos = None p1 = pais[0]['level'] p2 = pais[1]['level'] p1_lines = p1.split('\n') p2_lines = p2.split('\n') p1_header = p1_lines[0] p2_header = p2_lines[0] p1_map = p1_lines[1:] p2_map = p2_lines[1:] # O embaralho das caracteristicas dos pais low_limit = random.uniform(0, 0.75) high_limit = random.uniform(low_limit, 0.9) low_limit = round(low_limit * len(p1_map)) high_limit = round(high_limit * len(p1_map)) cross1 = [p1_header] + p1_map[:low_limit] + p2_map[low_limit:high_limit] + p1_map[high_limit:] cross2 = [p2_header] + p2_map[:low_limit] + p1_map[low_limit:high_limit] + p2_map[high_limit:] cross1 = '\n'.join(cross1) cross2 = '\n'.join(cross2) # Retorna a lista com a criança filho1 = { 'level': cross1, 'evaluate': 0.0, 'distance': 1.0, } filho2 = { 'level': cross2, 'evaluate': 0.0, 'distance': 1.0, } filhos = [filho1, filho2] return filhos ### - Alexandre Bender - ### - COMPLETO def crossover_discreto(fathers): """ Consiste em receber dois pais, e para cada gene presente neles, escolher aleatoriamente de qual pai herdar. Retorna dois filhos, onde um deles é o complemento dos valores sorteados primeiramente. Indivíduos possuem também informações de número de movimentos, pontuação do nível e quantidade de tipos de peças. Essas informações não são exatamente genes do indivíduo, mas sim características gerais extraídas com base nos genes do indivíduo, então requerem um tratamento especial: - Número de movimentos: Foi calculado utilizando uma média ponderada pela quantidade de genes herdada por cada pai. Se o indivíduo herdou 3 de 10 genes do pai A e 7 de 10 genes do pai B, ele irá possuir 30% do número de movimentos do pai A e 70% do número de movimentos do pai B (valor final arredondado). - Pontuação: Também foi calculada utilizando uma média ponderada pela quantidade de genes herdada por cada pai. Se o indivíduo herdou 3 de 10 genes do pai A e 7 de 10 genes do pai B, ele irá possuir 30% da pontuação do pai A e 70% da pontuação do pai B (valor final arredondado). - Quantidade de tipos de peças: Foi calculada probabilisticamente utilizando uma probabilidade ponderada pela quantidade de genes herdada por cada pai. Se o indivíduo herdou 3 de 10 genes do pai A e 7 de 10 genes do pai B, ele terá 30% de chance de herdar a quantidade de tipos de peças do pai A e 70% de chance de herdar a quantidade de tipos de peças do pai B. """ assert len(fathers) == 2 # Precisa ter exatamente 2 pais def print_to_string(*args, **kwargs): output = io.StringIO() print(*args, file=output, **kwargs, end='') contents = output.getvalue() output.close() return contents def string_to_int_list(string): string = io.StringIO(string) reader = csv.reader(string, delimiter=',') data = [] for row in reader: data.extend(row) data = list(map(int, data)) return data def int_list_to_string(int_list): string = '' term = print_to_string(int_list[0]) string += term + ',' term = print_to_string(int_list[1]) string += term + ',' term = print_to_string(int_list[2]) string += term + '\n' for i, gene in enumerate(int_list[3:]): term = print_to_string(gene) if (i + 1) % 9: string += term + ',' else: string += term + '\n' return string verbose = False father_a = fathers[0] father_b = fathers[1] father_a_map = father_a['level'] father_b_map = father_b['level'] father_a_map = string_to_int_list(father_a_map) father_b_map = string_to_int_list(father_b_map) child_a = [0, 0, 0] child_b = [0, 0, 0] random_list = [0, 0, 0] a_count = 0 b_count = 0 for i, (gene_a, gene_b) in enumerate(zip(father_a_map, father_b_map)): if i <= 2: continue random_bool = random.randint(0, 1) random_list.append(random_bool) if random_bool: b_count += 1 child_a.append(gene_b) child_b.append(gene_a) else: a_count += 1 child_a.append(gene_a) child_b.append(gene_b) a_ratio = a_count / 81 b_ratio = b_count / 81 move_amount = a_ratio * father_a_map[0] + b_ratio * father_b_map[0] move_amount_b = b_ratio * father_a_map[0] + a_ratio * father_b_map[0] child_a[0] = round(move_amount) child_b[0] = round(move_amount_b) score_amount = a_ratio * father_a_map[1] + b_ratio * father_b_map[1] score_amount_b = b_ratio * father_a_map[1] + a_ratio * father_b_map[1] child_a[1] = round(score_amount) child_b[1] = round(score_amount_b) weighted_sample = random.sample(random_list, 1)[0] if weighted_sample: child_a[2] = father_b_map[2] child_b[2] = father_a_map[2] else: child_a[2] = father_a_map[2] child_b[2] = father_b_map[2] child_a = int_list_to_string(child_a) child_b = int_list_to_string(child_b) child_a = { 'level' : child_a, 'evaluate': 0.0, 'distance': 1.0 } child_b = { 'level' : child_b, 'evaluate': 0.0, 'distance': 1.0 } return [child_a, child_b]

from itertools import product # Usado para conferir as combinações def avalia_combinacao(selecao, crossover, target, n_vezes): """ Este método fará todas as combinações dos métodos de seleção e crossover para cada um dos targets. Cada uma das combinações serão testadas n_vezes. Parâmetros: selecao -> lista de funções (métodos de seleção) crossover -> lista de funções (métodos de crossover) target -> lista de floats (targets desejados) n_vezes -> inteiro (quantidade de vezes que será feito o teste) """ # nome dos métodos s_name = selecao.__name__ c_name = crossover.__name__ # colunas usadas colunas = ['METODO_SELECAO', 'METODO_CROSSOVER', 'TARGET', 'TEMPO', 'NUMERO_GERACOES', 'FINALIZADO'] # arquivos utilizado filename = 'data/{0}_{1}_{2}.csv'.format(s_name, c_name, int(target*100)) # se o arquivo existe, leia o dataframe dele if os.path.isfile(filename): df = pd.read_csv(filename, sep=';') # caso não seja, cria o dataframe vazio else: df = pd.DataFrame(columns=colunas) # confere de onde irá começar os testes start = len(df.index) for _ in range(start, n_vezes): # Precisamos avaliar apenas os mapas # que foram gerados com mais de uma geração, # pois utilizou os métodos while True: # Retorna o resultado dos testes resultado = QuebraDoceGenerator().generate_level( target, s_method=selecao, c_method=crossover, ) # Saída do while if resultado['gen'] > 1: print('') # pra pular pra próxima linha break # Adiciona a coluna aos dados row = { 'METODO_SELECAO': s_name.upper(), 'METODO_CROSSOVER': c_name.upper(), 'TARGET': target, 'TEMPO': resultado['tempo'], 'NUMERO_GERACOES': resultado['gen'], 'FINALIZADO': resultado['completo'], } df = df.append(row, ignore_index=True) # Salva os dados df.to_csv(filename, sep=';', index=False) # Testes finalizados print('Dados para os testes [{},{},{}] completo!'.format(s_name, c_name, target)) def teste_metodos(lista_selecao, lista_crossover, targets=[.75, .85, .95], n_vezes=10): """ Este função organiza todos os testes possíveis para um conjunto de seleção, crossover e targets. Parâmetros: lista_selecao -> lista de funções (métodos de seleção) lista_crossover -> lista de funções (métodos de crossover) targets -> lista de floats (targets desejados) n_vezes -> Inteiro (quantidade de vezes que será feito o teste) """ # Combinações possiveis de [SELEÇÃO, CROSSOVER, TARGET] combinations = product(*[lista_selecao, lista_crossover, targets]) # Faz a avaliação de todas as combinações for s, c, t in combinations: print('TESTE - [{}, {}, {}]'.format(s.__name__.upper(), c.__name__.upper(), t)) avalia_combinacao(s, c, t, n_vezes) print('')