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)
