def generate_charts(ga: pyeasyga.GeneticAlgorithm): all_vals = [] best_vals = [] start = time_ns() ga.create_first_generation() all_vals.append([x.fitness for x in ga.current_generation]) best_vals.append(ga.current_generation[0].fitness) for _ in range(1, ga.generations): if ga.current_generation[0].fitness == 0: break ga.create_next_generation() all_vals.append([x.fitness for x in ga.current_generation]) best_vals.append(ga.current_generation[0].fitness) print(f'\nin {(time_ns() - start) / 1000000}ms') avg = [np.average(x) for x in all_vals] fig, ax = plt.subplots() ax.plot(best_vals, label="Max") ax.plot(avg, label="Avg") plt.xlabel("Generations") plt.ylabel("Value") legend = ax.legend(loc='lower right') plt.show()
if not existenDatosInvalidos(individual) and not existenDatosDuplicados( individual): fitness += britanicoCasaRoja(individual) fitness += suecoTienePerro(individual) fitness += danesTomaTe(individual) fitness += casaVerdeIzqACasaBlanca(individual) fitness += casaVerdeTomaTe(individual) fitness += fumaPallMallTienePajaro(individual) fitness += casaAmarillaFumaDunhill(individual) fitness += casaDelCentroTomaLeche(individual) fitness += noruegoEnPrimeraCasa(individual) fitness += fumaBrendsYVecinoTieneGato(individual) fitness += tieneCaballoYVecinoFumaDunhill(individual) fitness += fumaBluemastersYBebeCerveza(individual) fitness += alemanFumaPrince(individual) fitness += noruegoJuntoACasaAzul(individual) fitness += fumaBrendsYVecinoTomaAgua(individual) resultantes.append({'fitness': fitness, 'individual': individual}) return fitness ga = GeneticAlgorithm(datos, population_size=2000) ga.create_individual = create_individual ga.fitness_function = fitness ga.run() last = resultantes.pop() print(last.get('individual'))
def generate(target_params, insert_aa_seq, population_size=100, mutation_probability=0.3, max_gens_since_improvement=50, genetic_code=11, verbose=False): # back translate to an initial seq insert = "" for aa in insert_aa_seq: try: insert += Bio.Data.CodonTable.unambiguous_dna_by_id[ genetic_code].back_table[aa] except: if aa == "*": insert += Bio.Data.CodonTable.unambiguous_dna_by_id[ genetic_code].back_table[None] # create the genetic algorithm instance ga = GeneticAlgorithm(dna_to_vector(insert), crossover_probability=0, maximise_fitness=False, population_size=population_size, mutation_probability=mutation_probability) # get the target values of k k = list(target_params.keys()) # generate the target vector from the input dict target = np.array([]) for _k in sorted([x for x in k if x != "codons"]): target = np.concatenate((target, [ x[1] for x in sorted(target_params[_k].items(), key=lambda x: x[0]) ])) if "codons" in k: target = np.concatenate((target, [ x[1] for x in sorted(target_params["codons"].items(), key=lambda x: x[0]) ])) def vector(seq): output = k_mer_frequencies(seq, [x for x in k if x != "codons"], include_missing=True, vector=True) if "codons" in k: output = np.concatenate((output, [ x[1] for x in sorted(codon_frequencies(seq, genetic_code).items(), key=lambda x: x[0]) ])) return output def fitness(individual, data): individual = vector_to_dna(individual) # fitness = np.linalg.norm(target - vector(individual)) fitness = jensen_shannon_divergence([ dit.ScalarDistribution(target), dit.ScalarDistribution(vector(individual)) ]) return fitness ga.fitness_function = fitness synonymous_codons = _synonymous_codons(genetic_codes[genetic_code]) def mutate(individual): while True: # choose a random codon codon_idx = np.random.randint(len(individual) / 6) * 6 # figure out which codon it is codon = vector_to_dna(individual[codon_idx:codon_idx + 6]) # ensure that mutations actually change the sequence if len(synonymous_codons[codon]) != 1: break # choose a new one at random for the AA new_codon = dna_to_vector( np.random.choice( [x for x in synonymous_codons[codon] if x != codon])) # replace it in the individual individual[codon_idx:codon_idx + 6] = new_codon return individual ga.mutate_function = mutate def create_individual(seed_data): individual = vector_to_dna(seed_data) new = "" for codon in [ individual[i:i + 3] for i in range(0, len(individual), 3) ]: if len(synonymous_codons[codon]) == 1: new += codon continue new += np.random.choice( [x for x in synonymous_codons[codon] if x != codon]) return dna_to_vector(new) ga.create_individual = create_individual # set up for GA run ga.create_first_generation() gens_since_improvement = 0 best_indv_fitness = ga.best_individual()[0] counter = 1 # run the GA while gens_since_improvement < max_gens_since_improvement: ga.create_next_generation() if ga.best_individual()[0] < best_indv_fitness: best_indv_fitness = ga.best_individual()[0] gens_since_improvement = 0 else: gens_since_improvement += 1 if verbose: print( "Gen: %s\tSince Improvement: %s/%s\tFitness: %s".expandtabs(15) % (counter, gens_since_improvement, max_gens_since_improvement, ga.best_individual()[0]), end="\r") counter += 1 if verbose: print() best_seq = vector_to_dna(ga.best_individual()[1]) best_freqs = vector(best_seq) return best_seq
from pyeasyga.pyeasyga import GeneticAlgorithm import random import numpy as np # Формат задания значений (y(x), [x]) data = (4.0, [-2.0]) # Параметры работы генетического алгоритма # (начальные данные, кол-во особей в популяции, кол-во генераций, вероятность применения оператора скрещивания, вероятность применения мутации к гену, вкл. выбор лучшей особи, максимизация целевой функции) ga = GeneticAlgorithm(data, 20, 30, 0.7, 0.01, True, False) # Функция создания начальной популяции def create_individual(data): # Вещественное кодирование ind = [random.uniform(-4.0, 4.0)] # Вывод начальной популяции на экран print(ind[0] * ind[0] + 4, ind) return ind #[random.uniform(-4.0, 4.0) for _ in range(len(data))] ga.create_individual = create_individual # Функция кроссинговера ГА (арифметический кроссинговер, lambda = 0.2) def crossover(parent_1, parent_2): child_1 = [parent_1[0] * 0.2 + parent_2[0] * 0.8] child_2 = [parent_2[0] * 0.2 + parent_1[0] * 0.8] return child_1, child_2
from pyeasyga.pyeasyga import GeneticAlgorithm import random data = [('pear', 50), ('apple', 35), ('banana', 40)] ga = GeneticAlgorithm(data, 20, 50, 0.8, 0.2, True, True) def create_individual(data): print("***CREATE INDIVIDUAL***") ind = [random.randint(0, 1) for _ in xrange(len(data))] print(ind) return ind ga.create_individual = create_individual def crossover(parent_1, parent_2): crossover_index = random.randrange(1, len(parent_1)) child_1 = parent_1[:crossover_index] + parent_2[crossover_index:] child_2 = parent_2[:crossover_index] + parent_1[crossover_index:] print("***HERENCIA***") print(child_1) print(child_2) return child_1, child_2 ga.crossover_function = crossover def mutate(individual):
parser.add_argument('--adaptive_mutation_factor', default=1.3, type=float, help='enter a decimal value for how much to multiply mutation rate per generation') parser.add_argument('--clipping_threshold', default=0.9, type=float, help='enter a decimal between 0 and 1 at which clipping is performed') parser.add_argument('--turbines', default=2, type=int, help='enter an integer number of turbines to start with') parser.add_argument('--grid_size', default=36, type=int, help='enter an perfect square integer representing grid size (e.g. 6x6 is 36)') args = parser.parse_args() given_crossover_probability = args.crossover_probability given_mutation_probability = args.starting_mutation_probability given_adaptive_mutation_factor = args.adaptive_mutation_factor given_clipping_threshold = args.clipping_threshold given_turbines = args.turbines grid_size= args.grid_size input_data = [0]*grid_size # length of this list is the # of grid cells in layout easyga = GeneticAlgorithm(input_data, crossover_probability =given_crossover_probability , mutation_probability=given_mutation_probability, adaptive_mutation_factor = given_adaptive_mutation_factor, clipping_threshold = given_clipping_threshold, num_turbines = given_turbines) easyga.fitness_function = fitness easyga.run() print(easyga.best_individual()) def fitness (individual, data): freestream_velocity = 15 individual_2D_list = [[individual[0], individual[1]],[individual[2], individual[3]]] individual_np = np.asarray(individual_2D_list) velocities = np.zeros(individual_np.shape) alpha = .9 # entrainment constant x = 150 # distance between perpendicular turbine centers r = 40 # radius of turbine
from pyeasyga.pyeasyga import GeneticAlgorithm import random import numpy as np data = (-0.5, [-2.0]) #Формат задания значений (y(x), [x]) #Задаём параметры работы генетического алгоритма ga = GeneticAlgorithm(data, 20, 30, 0.7, 0.01, True, True) #(начальные данные, количество особей в популяции, количество генераций, вероятность применения оператора скрещивания, вероятность применения мутации к гену, вкл. выбор лучшей особи, максимизация целевой функции) def create_individual(data): #Функция создания начальной популяции ind = [random.uniform(-4.0, -1e-10)] #Вещественное кодирование print(1 / ind[0], ind) #Вывод начальной популяции на экран return ind #[random.uniform(-4.0, -0.1) for _ in range(len(data))] ga.create_individual = create_individual def crossover(parent_1, parent_2): #Функция кроссинговера ГА (арифметический кроссинговер, lambda = 0.2) child_1 = [parent_1[0] * 0.2 + parent_2[0] * 0.8] child_2 = [parent_2[0] * 0.2 + parent_1[0]* 0.8] return child_1, child_2 ga.crossover_function = crossover def mutate(individual): #Функция мутации для вещественного кодирования rnd = np.random.normal(0, 0.5) if rnd < -0.5: rnd = -0.5 elif rnd > 0.5: rnd = 0.5 individual[0] = individual[0] + rnd ga.mutate_function = mutate
'materia': Materia.CUATRO.value, 'dia1': Dia.SABADO.value, 'dia2': Dia.NA.value, 'turno1': Turno.MAÑANA.value, 'turno2': Turno.NA.value, 'horario1i': Horario.CERO.value, 'horario2i': Horario.NA.value, 'horario1f': Horario.CINCO.value, 'horario2f': Horario.NA.value }, ] ga = GeneticAlgorithm(data, population_size=100, generations=25, crossover_probability=0.8, mutation_probability=0.04, elitism=True, maximise_fitness=True) def supHorario(M1_H1I, M1_H1F, M1_H2I, M1_H2F, M2_H1I, M2_H1F, M2_H2I, M2_H2F): if (M1_H1F < M2_H1I) and (M1_H1I > M2_H1F): return False else: return True def supDia(M1D1, M1D2, M2D1, M2D2): if M1D2 == [1, 1, 0] or M2D2 == [1, 1, 0]: return M1D1 == M2D1 or M1D2 == M2D1 or M1D1 == M2D2
# insert flatten individual_copy = copy.deepcopy(individual) individual_copy.insert(0, Convolution(input_shape=(32, 32, 3))) individual_copy.append(Classification(net_size=10, activation=None)) border_idx = find_module_border(individual_copy) individual_copy.insert(border_idx + 1, Flatten()) # print rules = [] for item in individual_copy: rules.append(str(item)) final_network = "\n".join(rules) print(final_network) # do the math _fitness, loss = get_network_fitness(final_network) all_accuracies.append(_fitness) all_losses.append(loss) print('=========================================================') return _fitness data = [["conv", "pool"], "flatten", "dense"] ga = GeneticAlgorithm(data, 20, 50, 0.8, 0.2, True, True) ga.create_individual = create_individual ga.crossover_function = crossover ga.mutate_function = mutate ga.selection_function = selection ga.fitness_function = fitness
from pyeasyga.pyeasyga import GeneticAlgorithm from random import random data = [('pear', 50), ('apple', 35), ('banana', 40)] ga = GeneticAlgorithm(data, population_size=40, generations=20, crossover_probability=0.8, mutation_probability=0.9, elitism=True, maximise_fitness=True) def fitness (individual, data): fitness = 0 if individual.count(1) == 3: for (selected, (fruit, profit)) in zip(individual, data): if selected: fitness += profit return fitness ga.fitness_function = fitness ga.run() print (ga.best_individual()) for individual in ga.last_generation(): print (individual)
def generate(target_params, insert_aa_seq, population_size=100, mutation_probability=0.3, crossover_probability=0.8, max_gens_since_improvement=50, genetic_code=11, verbose=False): '''Generate a sequence matching :math:`k`-mer usage. Args: target_params (dict): The parameters to optimize towards. Should be of the format {:math:`k_n`: {:math:`k_{n1}`: 0.2, :math:`k_{n2}`: 0.3,...}...} insert_aa_seq (str): The amino acid sequence for the optimized sequence. population_size (int, optional): The size of the population for the genetic algorithm. Defaults to 100. mutation_probability (float, optional): The likelihood of changing each member of each generation. Defaults to 0.3. crossover_probability (float, optional): The likelihood of each member of the population undergoing crossover. Defaults to 0.8. max_gens_since_improvement (int, optional): The number of generations of no improvement after which to stop optimization. Defaults to 50. genetic_code (int, optional): The genetic code to use. Defaults to 11, the standard genetic code. verbose (bool, optional): Whether to print the generation number, generations since improvement, and fitness. Defaults to false. Returns: str: The generated sequence. ''' # back translate to an initial seq insert = "" for aa in insert_aa_seq: try: insert += Bio.Data.CodonTable.unambiguous_dna_by_id[genetic_code].back_table[aa] except: if aa == "*": insert += Bio.Data.CodonTable.unambiguous_dna_by_id[genetic_code].back_table[None] # create the genetic algorithm instance ga = GeneticAlgorithm(dna_to_vector(insert), crossover_probability=crossover_probability, maximise_fitness=False, population_size=population_size, mutation_probability=mutation_probability) # get the target values of k k = list(target_params.keys()) # generate the target vector from the input dict target = np.array([]) for _k in sorted([x for x in k if x != "codons"]): target = np.concatenate((target, [x[1] for x in sorted(target_params[_k].items(), key=lambda x: x[0])])) if "codons" in k: target = np.concatenate((target, [x[1] for x in sorted(target_params["codons"].items(), key=lambda x: x[0])])) def vector(seq): output = k_mer_frequencies(seq, [x for x in k if x != "codons"], include_missing=True, vector=True) if "codons" in k: output = np.concatenate((output, [x[1] for x in sorted(codon_frequencies(seq, genetic_code).items(), key=lambda x: x[0])])) return output def fitness(individual, data): individual = vector_to_dna(individual) # fitness = np.linalg.norm(target - vector(individual)) fitness = jensen_shannon_divergence([dit.ScalarDistribution(target), dit.ScalarDistribution(vector(individual))]) return fitness ga.fitness_function = fitness synonymous_codons = _synonymous_codons(genetic_codes[genetic_code]) def mutate(individual): while True: # choose a random codon codon_idx = np.random.randint(len(individual) / 6) * 6 # figure out which codon it is codon = vector_to_dna(individual[codon_idx:codon_idx+6]) # ensure that mutations actually change the sequence if len(synonymous_codons[codon]) != 1: break # choose a new one at random for the AA new_codon = dna_to_vector(np.random.choice([x for x in synonymous_codons[codon] if x != codon])) # replace it in the individual individual[codon_idx:codon_idx+6] = new_codon return individual ga.mutate_function = mutate def crossover(parent_1, parent_2): parent_1, parent_2 = list(parent_1), list(parent_2) index = random.randrange(1, len(parent_1) / 6) * 6 child_1 = parent_1[:index] + parent_2[index:] child_2 = parent_2[:index] + parent_1[index:] return child_1, child_2 ga.crossover_function = crossover def create_individual(seed_data): individual = vector_to_dna(seed_data) new = "" for codon in [individual[i:i+3] for i in range(0, len(individual), 3)]: if len(synonymous_codons[codon]) == 1: new += codon continue new += np.random.choice([x for x in synonymous_codons[codon] if x != codon]) return dna_to_vector(new) ga.create_individual = create_individual # set up for GA run ga.create_first_generation() gens_since_improvement = 0 best_indv_fitness = ga.best_individual()[0] counter = 1 # run the GA try: while gens_since_improvement < max_gens_since_improvement: ga.create_next_generation() if ga.best_individual()[0] < best_indv_fitness: best_indv_fitness = ga.best_individual()[0] gens_since_improvement = 0 else: gens_since_improvement += 1 if verbose: print("Gen: %s\tSince Improvement: %s/%s\tFitness: %s".expandtabs(15) % (counter, gens_since_improvement, max_gens_since_improvement, ga.best_individual()[0]), end="\r") counter += 1 except KeyboardInterrupt: print("\nStopping early...") if verbose: print() best_seq = vector_to_dna(ga.best_individual()[1]) best_freqs = vector(best_seq) assert Seq(best_seq).translate(genetic_code) == Seq(insert).translate(genetic_code) return best_seq
print(iterations) matriz_gerada = list() i = 0 while (i < len(iterations)): matriz_gerada.insert(i, iterations[i]['node_count']) i += 1 # Ready CSV arq = open("casos_sj.csv") sirSjCsv = csv.DictReader(arq, fieldnames=["R", "I"]) sirSj = list() sirI = list() sirR = list() i = 0 for row in sirSjCsv: sirSj.insert(i, {"I": row['I'], "R": row['R']}) sirI.append(row['I']) sirR.append(row['R']) i += 1 print(sirSj) data = sirSj ga = GeneticAlgorithm(data) print(data[1, "R"]) print(type(data))
i = np.random.randint(N) j = np.random.randint(N) if i != j: adj_mat[i, j] = 0 adj_mat[j, i] = 0 return adj_mat N = 10 adj_mat = generate_adj_mat(N) print("Szombszédsági mátrix:") print(adj_mat) ga = GeneticAlgorithm(list(range(N)), 500, 200) def create_individual(data): return np.random.randint(0, N, len(data)) ga.create_individual = create_individual def crossover(parent1, parent2): c_idx = random.randrange(1, parent1.shape[0]) child_1 = np.append(parent1[:c_idx], parent2[c_idx:]) child_2 = np.append(parent2[:c_idx], parent1[c_idx:]) return child_1, child_2
#Импортим генетический алгоритм from pyeasyga.pyeasyga import GeneticAlgorithm import random import numpy as np #Представление данных #Данные представляют из себя множество нулей с одной единицей на какой-либо позиции #Это позиция отражает положение x на оси абсцисс от -4 до 0 seed_data = [0] * 399 seed_data.append(1) #Иницилизируем генетический алгоритм с заданными данными, а также размером #популяции, количеством поколений, шансом на кроссинговер и мутацию ga = GeneticAlgorithm(seed_data, 400, 200, 0.7, 0.05, True, True) #Представляем отдельную особь как случайное положение х def create_individual(data): individual = data[:] random.shuffle(individual) return individual ga.create_individual = create_individual #Одноточечный кроссинговер def crossover(parent_1, parent_2): crossover_index = random.randrange(1, len(parent_1)) child_1a = parent_1[:crossover_index] child_1b = [i for i in parent_2 if i not in child_1a]
# Импортирование генетического алгоритма from pyeasyga.pyeasyga import GeneticAlgorithm import random import numpy as np # Представление данных # Данные - множество нулей с одной единицей на какой-либо позиции # Позиция отражает положение x на оси абсцисс от -2 до 2 seed_data = [0] * 200 seed_data.append(1) # Иницилизируем генетический алгоритм #(начальные данные, кол-во особей в популяции, кол-во генераций, вероятность применения оператора скрещивания, вероятность применения мутации к гену, вкл. выбор лучшей особи, максимизация целевой функции) ga = GeneticAlgorithm(seed_data, 400, 200, 0.7, 0.05, True, False) # Отдельная особь, как случайное положение х def create_individual(data): individual = data[:] random.shuffle(individual) return individual ga.create_individual = create_individual # Одноточечный кроссинговер def crossover(parent_1, parent_2): crossover_index = random.randrange(1, len(parent_1)) child_1a = parent_1[:crossover_index] child_1b = [i for i in parent_2 if i not in child_1a]
def Genetic_al(model, data, i, stud1): ga = GeneticAlgorithm(data, population_size=100, generations=100, crossover_probability=0.01, mutation_probability=0.01, elitism=False, maximise_fitness=False) def create_individual(data): return [ float(1.0 + 5.0 * random.uniform(0, 1)), # Drop time actual float(1.0 + 15.0 * random.uniform(0, 1)), # Drop time actual_EWMA float(1.0 + 15.0 * random.uniform(0, 1)), # Drop time difference float(1.0 + 15.0 * random.uniform(0, 1)), # Drop time difference_EWMA # float((random.randint(300, 4000) + random.uniform(0, 1))),# Energy # float((random.randint(300, 4000) + random.uniform(0, 1))), # Energy_EWMA float(1.0 + 2.0 * random.uniform(0, 1)), # Lift Height actual float(1.0 + 2.0 * random.uniform(0, 1)), # Lift Height actual_EWMA # float((random.randint(0, 2) + random.uniform(0, 1))), # lift height ref # float((random.randint(0, 2) + random.uniform(0, 1))), # lift height ref_EWMA float(15.0 + 40.0 * random.uniform(0, 1)), # Main Weldcurrent voltage actual float(15.0 + 4.0 * random.uniform(0, 1) ), # Main Weldcurrent voltage actual_EWMA # ((random.randint(25, 50) + random.uniform(0, 1))),# Main Weldcurrent voltage Max # ((random.randint(25, 50) + random.uniform(0, 1))), # Main Weldcurrent voltage Max_EWMA # ((random.randint(8, 28) + random.uniform(0, 1))), # Main Weldcurrent voltage Min # ((random.randint(8, 28) + random.uniform(0, 1))), # Main Weldcurrent voltage Min_EWMA # (-(random.randint(1, 3) + random.uniform(0, 1))), # Penetration Max # (-(random.randint(1, 3) + random.uniform(0, 1))), # Penetration Max_EWMA # (-(random.randint(0, 3) + random.uniform(0, 1))), # Penetration Min # (-(random.randint(0, 3) + random.uniform(0, 1))), # Penetration Min_EWMA # (-(random.randint(0, 3) + random.uniform(0, 1))),# Penetratiom Ref # (-(random.randint(0, 3) + random.uniform(0, 1))), # Penetratiom Ref_EWMA float(8.0 + 35.0 * random.uniform(0, 1)), # Pilot Weldcurrent Arc Voltage Act float(8.0 + 35.0 * random.uniform(0, 1) ), # Pilot Weldcurrent Arc Voltage Act_EWMA # ((random.randint(20, 50) + random.uniform(0, 1))),# Pilot Weldcurrent Arc Voltage Max # ((random.randint(20, 50) + random.uniform(0, 1))), # Pilot Weldcurrent Arc Voltage Max_EWMA # ((random.randint(5, 20) + random.uniform(0, 1))),# Pilot Weldcurrent Arc Voltage Min # ((random.randint(5, 20) + random.uniform(0, 1))), # Pilot Weldcurrent Arc Voltage Min_EWMA float(1.5 + 8.0 * random.uniform(0, 1)), # Stickout float(1.5 + 8.0 * random.uniform(0, 1)), # Stickout_EWMA float(500.0 + 1000.0 * random.uniform(0, 1)), # Weldcurrent actual Positive float(500.0 + 1000.0 * random.uniform(0, 1)), # Weldcurrent actual Positive_EWMA float(-1500.0 + 1500.0 * random.uniform(0, 1)), # Weldcurrent actual Negative float(-1500.0 + 1500.0 * random.uniform(0, 1)), # Weldcurrent actual Negative_EWMA float(10.0 + 100.0 * random.uniform(0, 1)), # Weld time actual float(10.0 + 100.0 * random.uniform(0, 1)) ] # Weld time actual_EWMA # ((random.randint(10, 100) + random.uniform(0, 1))), # Weldtime ref # ((random.randint(10, 100) + random.uniform(0, 1)))] # Weldtime ref_EWMA ga.create_individual = create_individual def eval_fitness(individual, data): array = np.array(individual)[np.newaxis] error_array = [] error = (model.predict(array, batch_size=1) + 2)**2 error_array.append(individual) print('Evaluating... error: ' + str(error)) return error ga.fitness_function = eval_fitness ga.run() Gen1 = pd.DataFrame(ga.last_generation()) filepath = "C:\\Users\PHLEGRA\Desktop\MASTER\Data_intersection\Prescribed_parameters\\new" filename = str(stud1) + "_" + str(i) + '_predictions.csv' Gen1.to_csv(filepath + '\\' + filename, index=False) print('Please see file. Process Complete')
import random import numpy as np from sklearn import datasets from sklearn.neural_network import MLPClassifier custom_data_home = 'D:\Christian-Data\Proyectos\Python\data' mnist = datasets.fetch_mldata('MNIST original', data_home=custom_data_home) X, y = mnist.data / 255., mnist.target X_train, X_test = X[:60000], X[60000:] y_train, y_test = y[:60000], y[60000:] data = [('uno', 1)] ga = GeneticAlgorithm(data, population_size=3, generations=3, crossover_probability=0.8, mutation_probability=0.02, elitism=True, maximise_fitness=True) #CREAR UN ELEMENTO PARA LA EVALUACION def create_individual(data): r_capas = random.randint(1, 5) r_nodos = random.randint(1, 50) f = [] for i in range(r_capas): f.append(r_nodos) print("***CREAR INDIVIDUO***") print(f) return f