for i in range(PARITY_SIZE_M): inputs[i] = [None] * PARITY_FANIN_M value = i dividor = PARITY_SIZE_M parity = 1 for j in range(PARITY_FANIN_M): dividor /= 2 if value >= dividor: inputs[i][j] = 1 parity = int(not parity) value -= dividor else: inputs[i][j] = 0 outputs[i] = parity pset = gp.PrimitiveSet("MAIN", PARITY_FANIN_M, "IN") pset.addPrimitive(operator.and_, 2) pset.addPrimitive(operator.or_, 2) pset.addPrimitive(operator.xor, 2) pset.addPrimitive(operator.not_, 1) pset.addTerminal(1) pset.addTerminal(0) creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) toolbox = base.Toolbox() toolbox.register("expr", gp.genFull, pset=pset, min_=3, max_=5) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual)
return x**2 cxpb = 0.7 # crossover rate mutpb = 0.2 # 1 - cxpb - elite # mutation rate size_pop = 400 Mu = int(size_pop) Lambda = int(size_pop * 1.3) terminals = 2 nEph = 2 limit_height = 10 limit_size = 20 size_gen = 100 hof = tools.HallOfFame(10) pset = gp.PrimitiveSet("MAIN", terminals) pset.addPrimitive(operator.add, 2, name='add') pset.addPrimitive(operator.sub, 2, name='sub') pset.addPrimitive(operator.mul, 2, name='mul') pset.addPrimitive(np.exp, 1, name='exp') pset.addPrimitive(pow2, 1, name='pow') pset.addPrimitive(np.cos, 1, name="cos") pset.addPrimitive(np.sin, 1, name="sin") pset.addTerminal(np.e, name="E") # pset.addPrimitive(gpprim.lf, 1) for i in range(nEph): pset.addEphemeralConstant("rand{}".format(i), lambda: round(random.uniform(-1, 1), 4)) pset.renameArguments(ARG0='x1') pset.renameArguments(ARG1='x2') ######## TOOLBOX OF FIRST GP##################################################
################## # TRAINING MODEL # ################## # Create Fitness class creator.create("FitnessClassification", base.Fitness, weights=(-1, -1, -1)) # Maximize TPR, TNR, minimize FPR, FNR # Create Individual class creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessClassification) # Initialize a primitive set that contains all the primitives we can use primitive_set = gp.PrimitiveSet("main", x_train.shape[1]) primitive_set.addPrimitive(np.add, arity=2) primitive_set.addPrimitive(np.subtract, arity=2) primitive_set.addPrimitive(np.multiply, arity=2) primitive_set.addPrimitive(np.negative, arity=1) primitive_set.addPrimitive(np.square, arity=1) # Rename arguments primitive_set.renameArguments(ARG0='Pclass') primitive_set.renameArguments(ARG1='Sex') primitive_set.renameArguments(ARG2='Age') primitive_set.renameArguments(ARG3='Sibsp') primitive_set.renameArguments(ARG4='Parch') primitive_set.renameArguments(ARG5='Fare') primitive_set.renameArguments(ARG6='Embarked')
res = np.sqrt(sum(err1**2)) + np.sqrt(sum(err2**2)) if flag is True: x = res + sum(abs(np.array(penalty))) # np.sqrt(sum(np.array(penalty) ** 2)) return x else: return res''' #### PARAMETERS DEFINITION ####### Ngenes = 1 limit_height = 10 limit_size = 15 nCost = 2 nVars = 2 psetR = gp.PrimitiveSet("Radial", 2) psetR.addPrimitive(operator.add, 2, name="Add") psetR.addPrimitive(operator.sub, 2, name="Sub") psetR.addPrimitive(operator.mul, 2, name='Mul') psetR.addPrimitive(gpprim.TriAdd, 3) psetR.addPrimitive(np.tanh, 1, name="Tanh") psetR.addPrimitive(gpprim.Sqrt, 1) psetR.addPrimitive(gpprim.Log, 1) psetR.addPrimitive(gpprim.modExp, 1) psetR.addPrimitive(gpprim.Sin, 1) psetR.addPrimitive(gpprim.Cos, 1) for i in range(nCost): psetR.addTerminal("randR{}".format(i), round(random.uniform(-10, 10), 6)) psetR.renameArguments(ARG0='errR')
from deap import creator from deap import tools from deap import gp from speciation import getInd_perSpecie import gp_conf as neat_gp from my_operators import safe_div, mylog, mypower2, mypower3, mysqrt, myexp #Imports de evospace import random, time import evospace import xmlrpclib import jsonrpclib import cherrypy_server pset = gp.PrimitiveSet("MAIN", 13) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(safe_div, 2) pset.addPrimitive(np.cos, 1) pset.addPrimitive(np.sin, 1) #pset.addPrimitive(myexp, 1) pset.addPrimitive(mylog, 1) pset.addPrimitive(mypower2, 1) pset.addPrimitive(mypower3, 1) pset.addPrimitive(mysqrt, 1) pset.addPrimitive(np.tan, 1) pset.addPrimitive(np.tanh, 1) pset.addEphemeralConstant("rand101", lambda: random.uniform(-1, 1)) pset.renameArguments(ARG0='x0',ARG1='x1', ARG2='x2', ARG3='x3', ARG4='x4', ARG5='x5', ARG6='x6', ARG7='x7', ARG8='x8', ARG9='x9', ARG10='x10', ARG11='x11', ARG12='x12')
# Define new functions def protectedDiv(left, right): try: return left / right except ZeroDivisionError: return 1 def protectedLog(x): return math.log(abs(x)) ARGS_SIZE = 8 pset = gp.PrimitiveSet("MAIN", ARGS_SIZE) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(math.cos, 1) pset.addPrimitive(math.sin, 1) pset.addEphemeralConstant("rand101", lambda: random.randint(-1, 1)) # pset.renameArguments(ARG0='x') args_map = dict([("ARG" + str(i), "x" + str(i + 1)) for i in range(ARGS_SIZE)]) pset.renameArguments(**args_map) creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax)
def mydeap(mungedtrain): import operator import math import random import numpy from deap import algorithms from deap import base from deap import creator from deap import tools from deap import gp inputs = mungedtrain.iloc[:, 2:10].values.tolist() outputs = mungedtrain['Survived'].values.tolist() # Define new functions def protectedDiv(left, right): try: return left / right except ZeroDivisionError: return 1 pset = gp.PrimitiveSet("MAIN", 8) # eight input pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(math.cos, 1) pset.addPrimitive(math.sin, 1) pset.addPrimitive(max, 2) pset.addPrimitive(min, 2) # add more? pset.addEphemeralConstant("rand101", lambda: random.uniform(-10, 10)) # adjust? pset.renameArguments(ARG0='x1') pset.renameArguments(ARG1='x2') pset.renameArguments(ARG2='x3') pset.renameArguments(ARG3='x4') pset.renameArguments(ARG4='x5') pset.renameArguments(ARG5='x6') pset.renameArguments(ARG6='x7') pset.renameArguments(ARG7='x8') creator.create("FitnessMin", base.Fitness, weights=(1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=3) # toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) def evalSymbReg(individual): # Transform the tree expression in a callable function func = toolbox.compile(expr=individual) # Evaluate the accuracy return sum( round(1. - (1. / (1. + numpy.exp(-func(*in_))))) == out for in_, out in zip(inputs, outputs)) / len(mungedtrain), toolbox.register("evaluate", evalSymbReg) toolbox.register("select", tools.selTournament, tournsize=3) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) random.seed(318) pop = toolbox.population(n=300) # hof = tools.HallOfFame(1) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", numpy.mean) mstats.register("std", numpy.std) mstats.register("min", numpy.min) mstats.register("max", numpy.max) pop, log = algorithms.eaSimple(pop, toolbox, 0.5, 0.2, 100, stats=mstats, halloffame=hof, verbose=True) # print(hof[0]) func2 = toolbox.compile(expr=hof[0]) return func2
from deap import base, creator, gp, tools #from sklearn.util import resample import matplotlib.pyplot as plt #import pygraphviz as pgv #import pandas as pd import operator import glob import math import csv import os import random # -------------------------------------------------# numParameters = 3 #this is arbitrary - will change based on how many we decide to use pset = gp.PrimitiveSet("main", numParameters) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) # add more operator types - keeping it at 3 for initial debugging pset.addEphemeralConstant("name", lambda: random.uniform(-1, 1)) # the above line (about adding ephemerals) is buggy with my IDE (Spyder). # if it's buggy for you, comment out, and instead use the below 2 lines #pset.addTerminal(1,) #comment this line out when you test it unless ephemeral is buggy for you too #pset.addTerminal(0,) #comment this line out when you test it unless ephemeral is buggy for you too creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin,
(x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape(-1, 784) x_test = x_test.reshape(-1, 784) x_train = x_train.astype("float32") x_test = x_test.astype("float32") x_train /= 255.0 x_test /= 255.0 y_train_cat = tf.keras.utils.to_categorical(y_train) y_test_cat = tf.keras.utils.to_categorical(y_test) pset = gp.PrimitiveSet("MAIN", 2) # Second arg is 2 because we have y and yhat pset.addPrimitive(add, 2) pset.addPrimitive(subtract, 2) pset.addPrimitive(multiply, 2) pset.addPrimitive(square, 1) pset.addPrimitive(protected_div, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(cos, 1) pset.addPrimitive(sin, 1) pset.addPrimitive(protected_sqrt, 1) pset.addPrimitive(protected_pow, 2) pset.addPrimitive(exp, 1) pset.addPrimitive(protected_ln, 1) pset.addPrimitive(protected_log, 1) pset.renameArguments(ARG0="y_true") # y
cond_pset.addEphemeralConstant("rand101", lambda: np.random.randint(0, 100), float) cond_pset.addEphemeralConstant("randbool", lambda: np.random.choice([True, False]), bool) cond_pset.addPrimitive(_if_then_else, [bool, float, float], float) cond_pset.renameArguments(ARG0='ones_diff_rows') cond_pset.renameArguments(ARG1='ones_diff_cols') cond_pset.renameArguments(ARG2='zeros_diff_rows') cond_pset.renameArguments(ARG3='zeros_diff_cols') cond_pset.renameArguments(ARG4='compare_blocks_rows') cond_pset.renameArguments(ARG5='compare_blocks_cols') cond_pset.renameArguments(ARG6='max_row_clue') cond_pset.renameArguments(ARG7='max_col_clue') # value pset: val_pset = gp.PrimitiveSet("MAIN", 8) val_pset.addPrimitive(operator.add, 2) val_pset.addPrimitive(operator.mul, 2) val_pset.renameArguments(ARG0='ones_diff_rows') val_pset.renameArguments(ARG1='ones_diff_cols') val_pset.renameArguments(ARG2='zeros_diff_rows') val_pset.renameArguments(ARG3='zeros_diff_cols') val_pset.renameArguments(ARG4='compare_blocks_rows') val_pset.renameArguments(ARG5='compare_blocks_cols') val_pset.renameArguments(ARG6='max_row_clue') val_pset.renameArguments(ARG7='max_col_clue') val_pset.addEphemeralConstant("rand101_1", lambda: np.random.randint(0, 100)) # creator stuff: creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("ValueTree", gp.PrimitiveTree, pset=val_pset)
self.matrix[-1].append("food") elif col == ".": self.matrix[-1].append("empty") elif col == "S": self.matrix[-1].append("empty") self.row_start = self.row = i self.col_start = self.col = j self.dir = 1 self.matrix_row = len(self.matrix) self.matrix_col = len(self.matrix[0]) self.matrix_exc = copy.deepcopy(self.matrix) ant = AntSimulator(600) pset = gp.PrimitiveSet("ANT", 0) pset.addPrimitive(ant.if_food_ahead, 2) pset.addPrimitive(prog2, 2) pset.addPrimitive(prog3, 3) pset.addTerminal(ant.move_forward) pset.addTerminal(ant.turn_left) pset.addTerminal(ant.turn_right) creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) toolbox = base.Toolbox() # Attribute generator toolbox.register("expr_init", gp.genFull, pset=pset, min_=1, max_=2)
data_dict_sv1[date][stock] = data_dict[date]['sv1'].to_numpy() data_dict_sv2[date][stock] = data_dict[date]['sv2'].to_numpy() data_dict_sv3[date][stock] = data_dict[date]['sv3'].to_numpy() data_dict_sv4[date][stock] = data_dict[date]['sv4'].to_numpy() data_dict_sv5[date][stock] = data_dict[date]['sv5'].to_numpy() data_dict_bv1[date][stock] = data_dict[date]['bv1'].to_numpy() data_dict_bv2[date][stock] = data_dict[date]['bv2'].to_numpy() data_dict_bv3[date][stock] = data_dict[date]['bv3'].to_numpy() data_dict_bv4[date][stock] = data_dict[date]['bv4'].to_numpy() data_dict_bv5[date][stock] = data_dict[date]['bv5'].to_numpy() # with open(path_save + os.sep + 'data_dict_price.pkl', 'wb') as f: # pkl.dump(data_dict_price, f, protocol=4) Layer1 = gp.PrimitiveSet("Layer1", 22) Layer1.addPrimitive(OperatorFunc.Add, 2) Layer1.addPrimitive(OperatorFunc.Sub, 2) Layer1.addPrimitive(OperatorFunc.Mul, 2) Layer1.addPrimitive(OperatorFunc.fsum, 1) Layer1.addPrimitive(OperatorFunc.fmean,1) Layer1.addPrimitive(OperatorFunc.fstd,1) Layer1.addPrimitive(OperatorFunc.fcorr,2) Layer1.addPrimitive(OperatorFunc.gbsumstd,2) Layer1.addPrimitive(OperatorFunc.gbmeanstd,2) Layer1.renameArguments( ARG0 = 'sp1', ARG1 = 'sp2', ARG2 = 'sp3', ARG3 = 'sp4', ARG4 = 'sp5', ARG5 = 'bp1', ARG6 = 'bp2', ARG7 = 'bp3', ARG8 = 'bp4', ARG9 = 'bp5',
numToAvg = 2 totalTimeAlive = 0 for i in range(numToAvg): score, timeAlive = runGame(individual) totalScore += score totalTimeAlive += timeAlive return (totalScore / numToAvg), (totalTimeAlive / numToAvg) # Parameters numGens = 40 popSize = 500 CXPB = 0.9 MUTPB = 0.02 adfset = gp.PrimitiveSet("adf", 2) adfset.addPrimitive(snake.if_danger_up, 2) adfset.addPrimitive(snake.if_danger_right, 2) adfset.addPrimitive(snake.if_danger_down, 2) adfset.addPrimitive(snake.if_danger_left, 2) adfset.addPrimitive(snake.if_danger_two_up, 2) adfset.addPrimitive(snake.if_danger_two_right, 2) adfset.addPrimitive(snake.if_danger_two_down, 2) adfset.addPrimitive(snake.if_danger_two_left, 2) adfset.addPrimitive(snake.if_food_up, 2) adfset.addPrimitive(snake.if_food_right, 2) adfset.addPrimitive(snake.if_food_down, 2) adfset.addPrimitive(snake.if_food_left, 2) # adfset.addTerminal(snake.changeDirectionUp) # adfset.addTerminal(snake.changeDirectionRight) # adfset.addTerminal(snake.changeDirectionDown)
slave_kwargs=slave_kwargs)) ret = run(menv.wait_slaves(30)) ret = run(menv.set_host_managers()) ret = run(menv.is_ready()) # Create the agents from deap import base from deap import tools from deap import creator from deap import gp import operator import numpy as np pset = gp.PrimitiveSet("MAIN", arity=2) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) # pset.addPrimitive(max, 2) # pset.addPrimitive(min, 2) # pset.addPrimitive(divide, 2) pset.addPrimitive(np.sin, 1) pset.addPrimitive(np.cos, 1) pset.addPrimitive(np.tan, 1) #pset.addPrimitive(np.arcsin, 1) #pset.addPrimitive(np.arccos, 1) #pset.addPrimitive(np.arctan, 1) # pset.addPrimitive(exp, 1) #pset.addPrimitive(np.sqrt, 1) # pset.addPrimitive(log, 1)
RAWFP EffortMM Test mode: 10-fold cross-validation Linear Regression Model EffortMM = 53.4674 * Hardware + 0.389 * AdjFP + -294.1583 === Summary === Correlation coefficient 0.3664 Root mean squared error 281.0625 <---------- Baseline ''' # Create primitive set with name and arity pset = gp.PrimitiveSet('EFFORT', 2) toolbox = toolbox_from_pset(pset) location = os.path.join(os.getcwd(), os.path.dirname(__file__)) data_path = os.path.join(location, '../kemerer.arff') data_blob = arff.loadarff(data_path) df = pd.DataFrame(data_blob[0]) # Weka shows that these columns corelate the best data = df[['Hardware', 'AdjFP', 'EffortMM']].copy() hardwares = data[['Hardware']].values.flatten().tolist() adjFPs = data[['AdjFP']].values.flatten().tolist() efforts = data[['EffortMM']].values.flatten().tolist()
relative_error += error # Must return the value as a list object. return [total_error / relative_error] """ =============================================================================================================== - Algorithm Configuration (this portion of code must remain in global scope as per DEAP requirements). =============================================================================================================== """ # Creating a new primitive node set. pset = gp.PrimitiveSet("main", config.training_data.shape[1] - 1) # Adding operators to the primitive set. pset.addPrimitive(np.add, 2) pset.addPrimitive(np.subtract, 2) pset.addPrimitive(np.multiply, 2) pset.addPrimitive(division, 2) # Adding some random terminals between a set range with a set #dp. pset.addEphemeralConstant( "randomTerm1", lambda: round( rd.randint(config.random_lower * 10000, config.random_upper * 10000) / 10000, 4)) # Tell the algorithm that we are trying to minimise the fitness function. creator.create("FitnessMin", base.Fitness, weights=(-1.0, ))
def main(): print("Make primitive set") pset = gp.PrimitiveSet("MAIN", 4) pset.addPrimitive(operators.div, 2, "div") pset.addPrimitive(operators.add, 2, "add") pset.addPrimitive(operators.sub, 2, "sub") pset.addPrimitive(operators.mul, 2, "mul") pset.addPrimitive(operators.sqrt, 1, "sqrt") pset.addTerminal(1) pset.renameArguments(ARG0="ep") pset.renameArguments(ARG1="ef") pset.renameArguments(ARG2="np") pset.renameArguments(ARG3="nf") creator.create("FitnessMax", base.Fitness, weights=(-1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) expr = gp.genHalfAndHalf(pset, min_=1, max_=4) tree = gp.PrimitiveTree(expr) print("Make toolbox") toolbox = base.Toolbox() #Initial population toolbox.register("expr_init", gp.genHalfAndHalf, min_=1, max_=4, pset=pset) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr_init) toolbox.register("population", tools.initRepeat, list, toolbox.individual) train_dic, test_dic = dataset.get_dataset() train_spectra_if = evaluate.spectra_list(train_dic['if']) test_spectra_if = evaluate.spectra_list(test_dic['if']) toolbox.register("evaluate", evalFormula, data_set=train_spectra_if, pset=pset) toolbox.register("select", tools.selTournament, tournsize=7) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=5)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=5)) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) mstats = tools.MultiStatistics(fitness=stats_fit) mstats.register("min", numpy.min) NUM_OF_FORMULAS = 10 CROSS_RATE = 1 MUT_RATE = 0.08 GENERATION = 80 POPULATION = 40 LOGS = False for i in range(1, NUM_OF_FORMULAS + 1): print(f"Begin GA for if. Formula {i}") pop = toolbox.population(n=POPULATION) pop, _ = algorithms.eaSimple(pop, toolbox, CROSS_RATE, MUT_RATE, GENERATION - 1, verbose=LOGS) pop = sorted(pop, key=lambda x: evaluate.calculate_fitness( gp.compile(x, pset), train_spectra_if)) best, best_train_res, best_test_res = str( pop[0]), evaluate.calculate_fitness( gp.compile(pop[0], pset), train_spectra_if)[0], evaluate.calculate_fitness( gp.compile(pop[0], pset), test_spectra_if)[0] print("Best of final population: ") print(best) print("Train results: ") print(str(best_train_res)) print("Test results: ") print(str(best_test_res)) formula_name = f"IF_GP_{i}" saveFormula(formula_name, best, best_test_res, best_train_res) train_spectra_asgn = evaluate.spectra_list(train_dic['assignment']) test_spectra_asgn = evaluate.spectra_list(test_dic['assignment']) toolbox.register("evaluate", evalFormula, data_set=train_spectra_asgn, pset=pset) for i in range(1, NUM_OF_FORMULAS + 1): print(f"Begin GA for assignment. Formula {i}") pop = toolbox.population(n=POPULATION) pop, _ = algorithms.eaSimple(pop, toolbox, CROSS_RATE, MUT_RATE, GENERATION - 1, verbose=LOGS) pop = sorted(pop, key=lambda x: evaluate.calculate_fitness( gp.compile(x, pset), train_spectra_asgn)) best, best_train_res, best_test_res = str( pop[0]), evaluate.calculate_fitness( gp.compile(pop[0], pset), train_spectra_asgn)[0], evaluate.calculate_fitness( gp.compile(pop[0], pset), test_spectra_asgn)[0] print("Best of final population: ") print(best) print("Train results: ") print(str(best_train_res)) print("Test results: ") print(str(best_test_res)) formula_name = f"ASGN_GP_{i}" saveFormula(formula_name, best, best_test_res, best_train_res) train_spectra_mc = evaluate.spectra_list(train_dic['method_call']) test_spectra_mc = evaluate.spectra_list(test_dic['method_call']) toolbox.register("evaluate", evalFormula, data_set=train_spectra_mc, pset=pset) for i in range(1, NUM_OF_FORMULAS + 1): print(f"Begin GA for method. Formula {i}") pop = toolbox.population(n=POPULATION) pop, _ = algorithms.eaSimple(pop, toolbox, CROSS_RATE, MUT_RATE, GENERATION - 1, verbose=LOGS) pop = sorted(pop, key=lambda x: evaluate.calculate_fitness( gp.compile(x, pset), train_spectra_mc)) best, best_train_res, best_test_res = str( pop[0]), evaluate.calculate_fitness( gp.compile(pop[0], pset), train_spectra_mc)[0], evaluate.calculate_fitness( gp.compile(pop[0], pset), test_spectra_mc)[0] print("Best of final population: ") print(best) print("Train results: ") print(str(best_train_res)) print("Test results: ") print(str(best_test_res)) formula_name = f"MC_GP_{i}" saveFormula(formula_name, best, best_test_res, best_train_res) train_spectra_seq = evaluate.spectra_list(train_dic['sequence']) test_spectra_seq = evaluate.spectra_list(test_dic['sequence']) toolbox.register("evaluate", evalFormula, data_set=train_spectra_seq, pset=pset) for i in range(1, NUM_OF_FORMULAS + 1): print(f"Begin GA for sequence. Formula {i}") pop = toolbox.population(n=POPULATION) pop, _ = algorithms.eaSimple(pop, toolbox, CROSS_RATE, MUT_RATE, GENERATION - 1, verbose=LOGS) pop = sorted(pop, key=lambda x: evaluate.calculate_fitness( gp.compile(x, pset), train_spectra_seq)) best, best_train_res, best_test_res = str( pop[0]), evaluate.calculate_fitness( gp.compile(pop[0], pset), train_spectra_seq)[0], evaluate.calculate_fitness( gp.compile(pop[0], pset), test_spectra_seq)[0] print("Best of final population: ") print(best) print("Train results: ") print(str(best_train_res)) print("Test results: ") print(str(best_test_res)) formula_name = f"SEQ_GP_{i}" saveFormula(formula_name, best, best_test_res, best_train_res)
# Mutation probability MUTPB = .15 opt_vars = ['f1_S'] wts_vars = tuple([1]) path = 'result_GP_1' verb = 1 eval_func = fitness.eval_function(opt_vars) # Result: eval_func -> auc = lambda(y_true, y_pred) # eval_func = fitness.eval_function(['auc', 'acc']) ## Result: eval_func -> auc, acc = lambda(y_true, y_pred) # GP operator set pset = gp.PrimitiveSet("MAIN", n_att) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(operator_set.plog, 1) pset.addPrimitive(operator_set.psqrt, 1) pset.addPrimitive(operator_set.pdiv, 2) pset.addPrimitive(operator_set.F, 1) # pset.addPrimitive(math.sin, 1) # pset.addPrimitive(math.cos, 1) # pset.addPrimitive(operator.neg, 1) ''' Multiparameter optimization opt_vars -> evaluation metrics wts_vars -> tuple with each metric weight
rgr = LinearRegression() prev_mae = np.mean( cross_val_score(rgr, X_train, y_train, scoring="neg_mean_absolute_error", cv=5)) # メインループ # resultsに特徴量数、学習データのAUCスコア(5-fold CV)、テストデータのAUCスコアを保持する # exprsに生成された特徴量の表記を保持する results = [] exprs = [] for i in range(100): # 構文木として利用可能な演算の定義 pset = gp.PrimitiveSet("MAIN", n_features) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(np.cos, 1) pset.addPrimitive(np.sin, 1) pset.addPrimitive(np.tan, 1) # 関数のデフォルト値の設定 toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=3) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual)
# Define new functions def protectedDiv(left, right): try: return left / right except ZeroDivisionError: return 0 #Global values sample = np.random.uniform(low=-10, high=10, size=(1000, )) avg_sample = float('%.4f' % np.average(sample)) #Set GP pset = gp.PrimitiveSet("MAIN", 1, "X") pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(math.cos, 1) pset.addPrimitive(math.sin, 1) pset.addEphemeralConstant("rand101", lambda: random.randint(-1, 1)) creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=10) toolbox.register("individual", tools.initIterate, creator.Individual,
from deap import algorithms from deap import base from deap import creator from deap import tools from deap import gp # Define new functions def protectedDiv(left, right): try: return left / right except ZeroDivisionError: return 1 pset = gp.PrimitiveSet("MAIN", 4) # four input variables pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.renameArguments(ARG0='ep') pset.renameArguments(ARG1='ef') pset.renameArguments(ARG2='np') pset.renameArguments(ARG3='nf') creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)