def _setup_pset(self):
if self.random_state is not None:
random.seed(self.random_state)
np.random.seed(self.random_state)
self._pset = gp.PrimitiveSetTyped('MAIN', [np.ndarray], Output_Array)
# Rename pipeline input to "input_df"
self._pset.renameArguments(ARG0='input_matrix')
# Add all operators to the primitive set
for op in self.operators:
if op.root:
# We need to add rooted primitives twice so that they can
# return both an Output_Array (and thus be the root of the tree),
# and return a np.ndarray so they can exist elsewhere in the tree.
p_types = (op.parameter_types()[0], Output_Array)
self._pset.addPrimitive(op, *p_types)
self._pset.addPrimitive(op, *op.parameter_types())
# Import required modules into local namespace so that pipelines
# may be evaluated directly
for key in sorted(op.import_hash.keys()):
module_list = ', '.join(sorted(op.import_hash[key]))
if key.startswith('tpot.'):
exec('from {} import {}'.format(key[4:], module_list))
else:
exec('from {} import {}'.format(key, module_list))
for var in op.import_hash[key]:
self.operators_context[var] = eval(var)
self._pset.addPrimitive(CombineDFs(), [np.ndarray, np.ndarray],
np.ndarray)
# Terminals
for _type in self.arguments:
type_values = list(_type.values)
if 'nthread' not in _type.__name__:
type_values += ['DEFAULT']
for val in type_values:
terminal_name = _type.__name__ + "=" + str(val)
self._pset.addTerminal(val, _type, name=terminal_name)
if self.verbosity > 2:
print('{} operators have been imported by TPOT.'.format(
len(self.operators)))
def _setup_pset(self):
self._pset = gp.PrimitiveSetTyped('MAIN', [np.ndarray], Output_DF)
# Rename pipeline input to "input_df"
self._pset.renameArguments(ARG0='input_matrix')
# Add all operators to the primitive set
for op in operators.Operator.inheritors():
if op.root:
# We need to add rooted primitives twice so that they can
# return both an Output_DF (and thus be the root of the tree),
# and return a np.ndarray so they can exist elsewhere in the
# tree.
p_types = (op.parameter_types()[0], Output_DF)
self._pset.addPrimitive(op, *p_types)
self._pset.addPrimitive(op, *op.parameter_types())
# Import required modules into local namespace so that pipelines
# may be evaluated directly
for key in sorted(op.import_hash.keys()):
module_list = ', '.join(sorted(op.import_hash[key]))
if key.startswith("tpot."):
exec('from {} import {}'.format(key[4:], module_list))
else:
exec('from {} import {}'.format(key, module_list))
for var in op.import_hash[key]:
self.operators_context[var] = eval(var)
self._pset.addPrimitive(CombineDFs(), [np.ndarray, np.ndarray],
np.ndarray)
# Terminals
int_terminals = np.concatenate((np.arange(0, 51,
1), np.arange(60, 110, 10)))
for val in int_terminals:
self._pset.addTerminal(val, int)
float_terminals = np.concatenate(
([1e-6, 1e-5, 1e-4, 1e-3], np.arange(0., 1.01, 0.01),
np.arange(2., 51., 1.), np.arange(60., 101., 10.)))
for val in float_terminals:
self._pset.addTerminal(val, float)
self._pset.addTerminal(True, Bool)
self._pset.addTerminal(False, Bool)
def test_pickle_tree_ephemeral(self):
pset = gp.PrimitiveSetTyped("MAIN", [], int, "IN")
pset.addPrimitive(operator.add, [int, int], int)
pset.addEphemeralConstant("E1", lambda: 2, int)
expr = gp.genFull(pset, min_=1, max_=1)
ind = creator.IndTree(expr)
ind.fitness.values = (1.0,)
ind_s = pickle.dumps(ind, pickle.HIGHEST_PROTOCOL)
ind_l = pickle.loads(ind_s)
msg = "Unpickled individual %s != pickled individual %s" % (str(ind), str(ind_l))
self.assertEqual(ind, ind_l, msg)
msg = "Unpickled fitness %s != pickled fitness %s" % (str(ind.fitness), str(ind_l.fitness))
self.assertEqual(ind.fitness, ind_l.fitness, msg)
def __init__(self, n=50, threshold=0.75, reproduction_cost=0.25):
self.queue = list()
self.threshold = threshold
self.reproduction_cost = reproduction_cost
self.pset = gp.PrimitiveSetTyped("main", [], bool)
self.pset.addPrimitive(operator.and_, [bool, bool], bool)
self.pset.addPrimitive(operator.or_, [bool, bool], bool)
self.pset.addPrimitive(operator.lt, [float, float], bool)
self.pset.addPrimitive(operator.lt, [float, float], bool)
self.pset.addPrimitive(operator.lt, [float, float], bool)
self.pset.addPrimitive(operator.lt, [float, float], bool)
self.pset.addEphemeralConstant("rand40",
lambda: round(random.random() * 40, 2),
float)
self.pset.addTerminal('price', float)
self.pset.addTerminal('price_old', float)
self.pset.addTerminal('volume', float)
self.pset.addTerminal('colourfulness', float)
self.creator = creator
self.creator.create("FitnessMin", base.Fitness, weights=(-1.0, ))
self.creator.create("Individual",
gp.PrimitiveTree,
fitness=creator.FitnessMin,
pset=self.pset)
self.toolbox = base.Toolbox()
self.toolbox.register("expr",
genGrow,
pset=self.pset,
min_=0,
max_=6,
type_=bool)
self.toolbox.register("individual", tools.initIterate,
creator.Individual, self.toolbox.expr)
self.toolbox.register("population", tools.initRepeat, list,
self.toolbox.individual)
self.toolbox.register("evaluate", self.fitness)
self.toolbox.register("select", tools.selTournament, tournsize=3)
self.toolbox.register("mate", gp.cxOnePoint)
self.toolbox.register("expr_mut", genGrow, min_=0, max_=2)
self.toolbox.register("mutate",
gp.mutUniform,
expr=self.toolbox.expr_mut,
pset=self.pset)
self.mongo = MongoClient(os.environ['MONGO_1_PORT_27017_TCP_ADDR'],
27017)
self.get_cursor(3)
self.cursor.execute('SELECT id FROM gieters')
self.all_ids = [value[0] for value in self.cursor.fetchall()]
self.update_queue()
def create_pset(in_type, in_types_length, out_type):
pset = gp.PrimitiveSetTyped("MAIN",
itertools.repeat(in_type, in_types_length),
out_type,
prefix="x")
# basic operators
pset.addPrimitive(ops.addition, [float,float], float)
pset.addPrimitive(ops.subtract, [float,float], float)
pset.addPrimitive(ops.multiply, [float,float], float)
pset.addPrimitive(ops.safediv, [float,float], float)
pset.addPrimitive(ops.modulus, [float,float], float)
pset.addPrimitive(ops.plus_mod_two, [float,float], float)
# logic operators
pset.addPrimitive(ops.equal, [float, float], float)
pset.addPrimitive(ops.not_equal, [float, float], float)
pset.addPrimitive(ops.gt, [float, float], float)
pset.addPrimitive(ops.lt, [float, float], float)
pset.addPrimitive(ops.AND, [float, float], float)
pset.addPrimitive(ops.OR, [float, float], float)
pset.addPrimitive(ops.xor, [float,float], float)
# bitwise operators
pset.addPrimitive(ops.bitand, [float,float], float)
pset.addPrimitive(ops.bitor, [float,float], float)
pset.addPrimitive(ops.bitxor, [float,float], float)
# unary operators
pset.addPrimitive(op.abs, [float], float)
pset.addPrimitive(ops.NOT, [float], float)
pset.addPrimitive(ops.factorial, [float], float)
# large operators
pset.addPrimitive(ops.power, [float,float], float)
pset.addPrimitive(ops.logAofB, [float,float], float)
pset.addPrimitive(ops.permute, [float,float], float)
pset.addPrimitive(ops.choose, [float,float], float)
# misc operators
pset.addPrimitive(ops.left, [float,float], float)
pset.addPrimitive(ops.right, [float,float], float)
pset.addPrimitive(min, [float,float], float)
pset.addPrimitive(max, [float,float], float)
# terminals
randval = "rand" + str(random.random())[2:] # so it can rerun from ipython
pset.addEphemeralConstant(randval,
lambda: random.random() * 100,
float)
pset.addTerminal(0.0, float)
pset.addTerminal(1.0, float)
return pset
def CreatePrimitiveSet(window_size, code_size):
"""TODO:"""
#About primitives:
# input types requires length (use lists)
# input types use list but arguments are seen as separate elements
# return type must be a class.
# return type must be hashable, so lists which are dynamic elements are not allowed.
kCS = code_size
kWS = window_size
pset = gp.PrimitiveSetTyped("GP-criptor", itertools.repeat(float, kWS**2),
tuple, "P")
pset.addPrimitive(codeFunction, [float] * kCS, tuple)
pset.addPrimitive(operator.add, [float, float], float)
pset.addPrimitive(operator.sub, [float, float], float)
pset.addPrimitive(operator.mul, [float, float], float)
pset.addPrimitive(protectedDiv, [float, float], float)
return pset
def __init__(self, x_train, y_train, excludes, header, config_file):
"""
https://deap.readthedocs.io/en/master/examples/gp_spambase.html
inputing features indexes are given after removing the target feature
"""
self.feature_names = update_indexes(original_list=config_file['inputing_features_gp'],
excludes=excludes,
header=header)
self.x_train = x_train[:, self.feature_names]
self.y_train = y_train
self.position_target = numpy.size(self.x_train, 1)
self.pset = gp.PrimitiveSetTyped("MAIN", itertools.repeat(float, self.position_target), float, "IN")
self.primitive_functions()
# Minimizing the error between the response of the genetic formula and the true response. MSE
creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin)
self.data = numpy.insert(self.x_train, numpy.size(self.x_train, 1), self.y_train, axis=1).tolist()
self.toolbox = base.Toolbox()
self.register_functions()
def build_primitive_set(self):
''' Define operators/terminals set. '''
# setup evolution env.
pset = gp.PrimitiveSetTyped(
'MAIN', # codename for the dataset
itertools.repeat(float,
self.nfeatures), # type and number of features
bool, # type of the target value
'f_', # a prefix to encode feature names
)
# boolean operators
pset.addPrimitive(operator.and_, [bool, bool], bool)
pset.addPrimitive(operator.or_, [bool, bool], bool)
pset.addPrimitive(operator.not_, [bool], bool)
# floating point operators
pset.addPrimitive(np.add, [float, float], float)
pset.addPrimitive(np.subtract, [float, float], float)
pset.addPrimitive(np.multiply, [float, float], float)
pset.addPrimitive(self.div, [float, float], float)
pset.addPrimitive(np.exp, [float], float)
pset.addPrimitive(np.sin, [float], float)
pset.addPrimitive(np.cos, [float], float)
pset.addPrimitive(np.log, [float], float)
# logic operators
pset.addPrimitive(operator.gt, [float, float], bool)
pset.addPrimitive(operator.lt, [float, float], bool)
pset.addPrimitive(operator.eq, [float, float], bool)
pset.addPrimitive(self.ifelse, [float, float], float)
# terminals
pset.addEphemeralConstant( # random constant
'rand' + str(time.time()), lambda: random.random() * 100, float)
pset.addTerminal(False, bool)
pset.addTerminal(True, bool)
return pset
def GP_Definitions(nfeatures):
# defined a new primitive set for strongly typed GP
pset = gp.PrimitiveSetTyped("MAIN", itertools.repeat(float, nfeatures),
bool, "IN")
# boolean operators
pset.addPrimitive(operator.and_, [bool, bool], bool)
pset.addPrimitive(operator.or_, [bool, bool], bool)
pset.addPrimitive(operator.not_, [bool], bool)
# floating point operators
# Define a safe division function
def safeDiv(left, right):
try:
return left / right
except ZeroDivisionError:
return 0
pset.addPrimitive(operator.add, [float, float], float)
pset.addPrimitive(operator.sub, [float, float], float)
pset.addPrimitive(operator.mul, [float, float], float)
pset.addPrimitive(safeDiv, [float, float], float)
# logic operators
# Define a new if-then-else function
def if_then_else(input, output1, output2):
if input: return output1
else: return output2
pset.addPrimitive(operator.lt, [float, float], bool)
pset.addPrimitive(operator.eq, [float, float], bool)
pset.addPrimitive(if_then_else, [bool, float, float], float)
# terminals
pset.addEphemeralConstant("rand100", lambda: random.random() * 100, float)
pset.addTerminal(False, bool)
pset.addTerminal(True, bool)
return pset
def __init__(self, population_size=100, generations=100,
mutation_rate=0.9, crossover_rate=0.05,
random_state=0, verbosity=0):
"""Sets up the genetic programming algorithm for pipeline optimization."""
self.population_size = population_size
self.generations = generations
self.mutation_rate = mutation_rate
self.crossover_rate = crossover_rate
self.verbosity = verbosity
if random_state > 0:
random.seed(random_state)
np.random.seed(random_state)
self.pset = gp.PrimitiveSetTyped('MAIN', [pd.DataFrame], pd.DataFrame)
self.pset.addPrimitive(self.decision_tree, [pd.DataFrame, int, int], pd.DataFrame)
self.pset.addPrimitive(self.random_forest, [pd.DataFrame, int, int], pd.DataFrame)
self.pset.addPrimitive(self._combine_dfs, [pd.DataFrame, pd.DataFrame], pd.DataFrame)
self.pset.addPrimitive(self._subset_df, [pd.DataFrame, int, int], pd.DataFrame)
self.pset.addPrimitive(self._dt_feature_selection, [pd.DataFrame, int], pd.DataFrame)
self.pset.addPrimitive(operator.add, [int, int], int)
self.pset.addPrimitive(operator.sub, [int, int], int)
self.pset.addPrimitive(operator.mul, [int, int], int)
for val in range(0, 101):
self.pset.addTerminal(val, int)
creator.create('FitnessMax', base.Fitness, weights=(1.0,))
creator.create('Individual', gp.PrimitiveTree, fitness=creator.FitnessMax)
self.toolbox = base.Toolbox()
self.toolbox.register('expr', gp.genHalfAndHalf, pset=self.pset, min_=1, max_=2)
self.toolbox.register('individual', tools.initIterate, creator.Individual, self.toolbox.expr)
self.toolbox.register('population', tools.initRepeat, list, self.toolbox.individual)
self.toolbox.register('compile', gp.compile, pset=self.pset)
self.toolbox.register('select', self._combined_selection_operator)
self.toolbox.register('mate', gp.cxOnePoint)
self.toolbox.register('expr_mut', gp.genFull, min_=0, max_=2)
self.toolbox.register('mutate', self._random_mutation_operator)
else:
label = False
if bool(f(*feature[:9])) == label:
result += 1
return result,
# Initialise fitness and individual classes
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax)
# Initialise toolbox
toolbox = base.Toolbox()
# set operators that can be used in tree.
pset = gp.PrimitiveSetTyped("MAIN", itertools.repeat(float, 9), bool, "IN")
pset.addPrimitive(operator.add, [float, float], float)
pset.addPrimitive(operator.sub, [float, float], float)
pset.addPrimitive(operator.mul, [float, float], float)
pset.addPrimitive(protected_div, [float, float], float)
pset.addPrimitive(operator.abs, [float], float)
pset.addPrimitive(square, [float], float)
pset.addPrimitive(math.sin, [float], float)
pset.addPrimitive(math.cos, [float], float)
# logic operators
# Define a new if-then-else function
def if_then_else(input, output1, output2):
if input:
return output1
"""
class Flag:
def __init__(self, val): self.val = val
#def __str__ (self): return str(self.val)
def __repr__(self): #return 'Flag("%s")' % self.val if self.val else 'Flag(None)'
return 'Flag(%s)' % self.val
"""
class Profiling:
values = [None, 'autofdo', 'pgo']
profiling = Profiling()
pset = gp.PrimitiveSetTyped("MAIN", (), Profiling)
for value in profiling.values:
pset.addTerminal(value, Profiling, name=str(value))
pset.addPrimitive(lambda x: x, (Profiling, ), Profiling, name="id")
"""
def __init__(self, f**k):
self.f**k = f**k
def __repr__(self): return 'Profiling(%s)' % repr(self.f**k)
pset = gp.PrimitiveSetTyped("MAIN", (), Profiling)
#pset.addPrimitive(Profiling, (int,), Profiling)
pset.addPrimitive(lambda x: x, (Profiling,), Profiling, name="id")
from deap import base, creator, gp, tools
from Tool import globalVars
from Tool.GeneralData import GeneralData
from GetData.loadData import load_data
from GeneticPogramming import scalarFunctions, singleDataFunctions, singleDataNFunctions, coupleDataFunctions
#%% initialize global vars
globalVars.initialize()
loadedData = load_data()
globalVars.list_vars()
#%% add primitives
pset = gp.PrimitiveSetTyped('main', [
GeneralData, GeneralData, GeneralData, GeneralData, GeneralData,
GeneralData
], GeneralData)
pset.renameArguments(ARG0='CLOSE')
pset.renameArguments(ARG1='OPEN')
pset.renameArguments(ARG2='HIGH')
pset.renameArguments(ARG3='LOW')
pset.renameArguments(ARG4='AMOUNT')
pset.renameArguments(ARG5='VOLUME')
for aName, primitive in [
o for o in getmembers(singleDataFunctions) if isfunction(o[1])
]:
print('add primitive from {:<20}: {}'.format('singleDataFunctions', aName))
pset.addPrimitive(primitive, [GeneralData], GeneralData, aName)
globalVars.logger.debug('prepare the pset......start')
except:
from Tool import globalVars
from GetData import load_all
load_all()
globalVars.logger.info('load gpMultiprocessWorker')
globalVars.logger.debug('prepare the pset......start')
try:
inputOfPset = list(
itertools.repeat(GeneralData, len(globalVars.materialData.keys())))
except AttributeError as ae:
print(ae)
inputOfPset = list(
itertools.repeat(GeneralData, len(globalVars.materialData.keys())))
pset = gp.PrimitiveSetTyped('main', inputOfPset, GeneralData)
for aName, primitive in [
o for o in getmembers(singleDataFunctions) if isfunction(o[1])
]:
# print('add primitive from {:<20}: {}'.format('singleDataFunctions', aName))
pset.addPrimitive(primitive, [GeneralData], GeneralData, aName)
for aName, primitive in [
o for o in getmembers(scalarFunctions) if isfunction(o[1])
]:
# print('add primitive from {:<20}: {}'.format('scalarFunctions', aName))
pset.addPrimitive(primitive, [GeneralData, int], GeneralData, aName)
for aName, primitive in [
o for o in getmembers(singleDataNFunctions) if isfunction(o[1])
]:
regression = 1
else:
gpFrameworkHelper.set_regression(False)
regression = 0
emade.create_representation(adfs=3, regression=regression)
emade.setObjectives(objectiveDict)
emade.setDatasets(datasetDict)
emade.setMemoryLimit(misc_dict['memoryLimit'])
emade.setCacheInfo(cache_dict)
emade.set_statistics(statisticsDict)
emade.buildClassifier()
# Initialize pset
pset = gp.PrimitiveSetTyped("MAIN", [EmadeDataPair], EmadeDataPair)
gpFrameworkHelper.addTerminals(pset)
gpFrameworkHelper.addPrimitives(pset)
terminals = {}
primitives = {}
ephemerals = {}
for item in pset.mapping:
if isinstance(pset.mapping[item], gp.Terminal):
terminals[item] = pset.mapping[item]
elif isinstance(pset.mapping[item], gp.Primitive):
primitives[item] = pset.mapping[item]
names = []
methods = dir(gp)
for method in methods:
pointer = getattr(gp, method)
if inspect.isclass(pointer) and issubclass(pointer, gp.Ephemeral):
return df_in
else:
return pd.rolling_min(df_in, abs(periods), min_periods=abs(periods))
def pd_std(df_in, periods):
if abs(periods) < 2:
return df_in
else:
return pd.rolling_std(df_in, abs(periods), min_periods=abs(periods))
pset = gp.PrimitiveSetTyped('MAIN', [pd_df_float,
pd_df_float,
pd_df_float,
pd_df_float,
pd_df_float,
pd_df_bool,
pd_df_bool],
pd_df_bool)
pset.renameArguments(ARG0='Open')
pset.renameArguments(ARG1='High')
pset.renameArguments(ARG2='Low')
pset.renameArguments(ARG3='Close')
pset.renameArguments(ARG4='Volume')
# need to have pd_df_bool terminals for GP to work
pset.renameArguments(ARG5='Ones')
pset.renameArguments(ARG6='Zeros')
pset.addPrimitive(sma, [pd_df_float, int], pd_df_float, name="sma")
pset.addPrimitive(ewma, [pd_df_float, int], pd_df_float, name="ewma")
def __init__(self, info):
# Extract agent info
self.env_name = info["env_name"]
self.pop_size = info["pop_size"]
self.max_gens = info["max_gens"]
self.num_eps = info["num_eps"]
self.num_steps = info["num_time_steps"]
self.term_fit = info["term_fit"]
self.mut_rate = info["mutation_rate"]
self.tour_size = info["tournament_size"]
# Primitive set
obs_types = [
float, float, float, float, float, float, float, float, float,
float, float, float, float, float, float, float, float, float,
float, float, float, float, float, float
]
self.pset = gp.PrimitiveSetTyped("main", obs_types, Action)
self.pset.renameArguments(ARG0="hull_angle",
ARG1="hul_angularVelocity",
ARG2="vel_x",
ARG3="vel_y",
ARG4="hip_joint_1_angle",
ARG5="hip_joint_1_speed",
ARG6="knee_joint_1_angle",
ARG7="knee_joint_1_speed",
ARG8="leg_1_ground_contact_flag",
ARG9="hip_joint_2_angle",
ARG10="hip_joint_2_speed",
ARG11="knee_joint_2_angle",
ARG12="knee_joint_2_speed",
ARG13="leg_2_ground_contact_flag",
ARG14="lidar_reading_1",
ARG15="lidar_reading_2",
ARG16="lidar_reading_3",
ARG17="lidar_reading_4",
ARG18="lidar_reading_5",
ARG19="lidar_reading_6",
ARG20="lidar_reading_7",
ARG21="lidar_reading_8",
ARG22="lidar_reading_9",
ARG23="lidar_reading_10")
self.pset.addPrimitive(self.ACCUM, [float, float, float, float],
Action)
self.pset.addPrimitive(self.IFLTE, [float, float, float, float], float)
# self.pset.addPrimitive(operator.add, 2)
# self.pset.addPrimitive(operator.sub, 2)
# self.pset.addPrimitive(operator.mul, 2)
# self.pset.addPrimitive(operator.neg, 1)
self.pset.addTerminal(0.0, float)
self.pset.addTerminal(0.25, float)
self.pset.addTerminal(0.5, float)
self.pset.addTerminal(1.0, float)
self.pset.addTerminal(0, float)
self.pset.addTerminal(1, float)
self.pset.addTerminal(Action(
np.random.uniform(low=-1.0, high=1.0, size=4)),
Action,
name="random_action")
# Program generation functions
creator.create("FitMax", base.Fitness, weights=(1.0, ))
creator.create("Individual",
gp.PrimitiveTree,
fitness=creator.FitMax,
pset=self.pset)
self.toolbox = base.Toolbox()
method = gp.genGrow if info["method"] == "grow" else gp.genFull
self.toolbox.register("gen_exp",
method,
pset=self.pset,
min_=1,
max_=info["max_depth"])
self.toolbox.register("gen_program", tools.initIterate,
creator.Individual, self.toolbox.gen_exp)
self.toolbox.register("gen_pop", tools.initRepeat, list,
self.toolbox.gen_program)
# Fitness evaluation function
self.toolbox.register("fit", self.fit)
# Genetic operators
self.toolbox.register("clone", self._clone)
self.toolbox.register("select",
tools.selTournament,
tournsize=self.tour_size)
self.toolbox.register("mut_gen_exp",
method,
pset=self.pset,
min_=0,
max_=info["max_depth"])
self.toolbox.register("mutate",
gp.mutUniform,
expr=self.toolbox.mut_gen_exp,
pset=self.pset)
# Statistics functions
self.stats = tools.Statistics(key=lambda indiv: indiv.fitness.values)
self.stats.register("avg", np.mean)
self.logbook = tools.Logbook()
def create_primitive_set(vectors_dimension):
pset = gp.PrimitiveSetTyped(
"gp_doc2vec_clusters",
[WordsVectorsCluster, WordsVectorsCluster, WordsVectorsCluster], list,
"x")
pset.addEphemeralConstant("k", generate_random_number, float)
# pset.addEphemeralConstant("k2", generate_random_number, float)
# pset.addEphemeralConstant("k3", generate_random_number, float)
# pset.addEphemeralConstant("k4", generate_random_number, float)
pset.addEphemeralConstant(
"l", lambda:
[generate_random_number() for i in range(0, vectors_dimension)], list)
# pset.addEphemeralConstant("t1", lambda: Type1([generate_random_number() for i in range(0, vectors_dimension)]), Type1)
# pset.addEphemeralConstant("t2", lambda: Type2([generate_random_number() for i in range(0, vectors_dimension)]), Type2)
# pset.addEphemeralConstant("t3", lambda: Type3([generate_random_number() for i in range(0, vectors_dimension)]), Type3)
# pset.addEphemeralConstant("t4", lambda: Type4([generate_random_number() for i in range(0, vectors_dimension)]), Type4)
pset.addTerminal(
Type1([generate_random_number() for i in range(0, vectors_dimension)]),
Type1)
pset.addTerminal(
Type2([generate_random_number() for i in range(0, vectors_dimension)]),
Type2)
pset.addTerminal(
Type3([generate_random_number() for i in range(0, vectors_dimension)]),
Type3)
pset.addTerminal(
Type4([generate_random_number() for i in range(0, vectors_dimension)]),
Type4)
pset.addPrimitive(add_type1, [WordsVectorsCluster], Type1)
pset.addPrimitive(sub_type1, [WordsVectorsCluster], Type1)
pset.addPrimitive(mul_type1, [WordsVectorsCluster], Type1)
pset.addPrimitive(div_type1, [WordsVectorsCluster], Type1)
pset.addPrimitive(pow_type1, [WordsVectorsCluster], Type1)
pset.addPrimitive(mul_type2, [float, Type1], Type2)
pset.addPrimitive(add_type3, [Type2, Type2, Type2], Type3)
pset.addPrimitive(sub_type3, [Type2, Type2, Type2], Type3)
pset.addPrimitive(mul_type3, [Type2, Type2, Type2], Type3)
pset.addPrimitive(div_type3, [Type2, Type2, Type2], Type3)
pset.addPrimitive(pow_type3, [Type2, Type2, Type2], Type3)
pset.addPrimitive(mul_type4, [float, Type3], Type4)
pset.addPrimitive(ident_final, [Type4], list)
# pset.addPrimitive(add, [WordsVectorsCluster], list)
# pset.addPrimitive(add_external1, [list, list, list], list)
# pset.addPrimitive(add_external2, [list, list], list)
#
# pset.addPrimitive(sub, [WordsVectorsCluster], list)
# pset.addPrimitive(sub_external1, [list, list, list], list)
# pset.addPrimitive(sub_external2, [list, list], list)
#
# pset.addPrimitive(mul, [WordsVectorsCluster], list)
# pset.addPrimitive(mul_scalar, [list, float], list)
# pset.addPrimitive(mul_external1, [list, list, list], list)
# pset.addPrimitive(mul_external2, [list, list], list)
#
# pset.addPrimitive(div, [WordsVectorsCluster], list)
# pset.addPrimitive(div_external1, [list, list, list], list)
# pset.addPrimitive(div_external2, [list, list], list)
#
# pset.addPrimitive(my_pow, [WordsVectorsCluster], list)
# pset.addPrimitive(my_pow_external1, [list, list, list], list)
# pset.addPrimitive(my_pow_external2, [list, list], list)
#
# pset.addPrimitive(norm_logistic, [list], list)
# pset.addPrimitive(norm_unit, [list], list)
# pset.addPrimitive(softmax, [list], list)
#
pset.addPrimitive(lambda x: x, [float], float, name="ident_float")
pset.addPrimitive(lambda x: x, [WordsVectorsCluster],
WordsVectorsCluster,
name="ident_wv_cluster")
return pset
try:
ans = math.exp(x)
except OverflowError:
ans = 0.0
return ans
def protectedSin(x):
return math.sin(x) if math.fabs(x) != float('inf') else 0.0
def protectedCos(x):
return math.cos(x) if math.fabs(x) != float('inf') else 1.0
pset = gp.PrimitiveSetTyped("main", [float], float)
pset.addPrimitive(operator.add, [float, float], float)
pset.addPrimitive(operator.sub, [float, float], float)
pset.addPrimitive(operator.mul, [float, float], float)
pset.addPrimitive(protectedDiv, [float, float], float)
pset.addPrimitive(operator.neg, [float], float)
pset.addPrimitive(protectedSin, [float], float)
pset.addPrimitive(protectedCos, [float], float)
pset.addPrimitive(protectedExp, [float], float)
pset.addPrimitive(logAbs, [float], float)
pset.addEphemeralConstant("randp1n1", lambda: 2.0 * random.random() - 1.0,
float)
pset.renameArguments(ARG0='x')
creator.create("FitnessMin", base.Fitness, weights=(-1.0, ))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin)
def configure(self, dataframe, positive_indices):
self.fitness_function = QueryDiscoveryFitnessFunction(dataframe, positive_indices)
pset = gp.PrimitiveSetTyped("MAIN", [str for x in dataframe.columns], bool)
pset.addPrimitive(operator.and_, [bool, bool], bool)
pset.addPrimitive(operator.or_, [bool, bool], bool)
pset.addPrimitive(operator.eq, [str, float], bool)
pset.addPrimitive(operator.gt, [str, float], bool)
pset.addPrimitive(operator.ge, [str, float], bool)
pset.addPrimitive(operator.lt, [str, float], bool)
pset.addPrimitive(operator.le, [str, float], bool)
pset.addPrimitive(operator.ne, [str, float], bool)
def notapplied(val):
return val
pset.addPrimitive(notapplied, [str], str)
pset.addPrimitive(notapplied, [float], float)
pset.addTerminal(True, bool)
# Get all possible values in the dataframe and use them as terminals
terminals = set()
for col in dataframe.columns:
for val in set(dataframe[col].values):
terminals.add(val)
for t in terminals:
pset.addTerminal(t, float)
col_names = {}
for i in range(len(dataframe.columns)):
arg = 'ARG' + str(i)
col_names[arg] = dataframe.columns[i]
pset.renameArguments(**col_names)
# Define minimization problem
creator.create('FitnessMin', base.Fitness, weights=(-1.0,))
creator.create('Individual', gp.PrimitiveTree, fitness=creator.FitnessMin)
min_depth = 2
max_depth = 10
toolbox = base.Toolbox()
# Initialization strategy
toolbox.register('expr', gp.genHalfAndHalf, pset=pset, min_=min_depth, max_=max_depth)
toolbox.register('individual', tools.initIterate, creator.Individual, toolbox.expr)
toolbox.register('population', tools.initRepeat, list, toolbox.individual)
toolbox.register("compile", gp.compile, pset=pset)
# Register fitness function
toolbox.register('evaluate', self.evaluate_fitness)
# Selection strategy
toolbox.register("select", tools.selDoubleTournament, parsimony_size=1.4, fitness_size=6, fitness_first=True)
# Crossover strategy
toolbox.register("mate", gp.cxOnePointLeafBiased, termpb=0.1)
# Mutation strategy
toolbox.register("expr_mut", gp.genFull, min_=min_depth, max_=max_depth)
toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset)
# Restrict max individual size
toolbox.decorate('mate', gp.staticLimit(operator.attrgetter('height'), max_value=max_depth))
return toolbox
def run(cxpb, mutpb, n, tour, termpb, popu, ngen):
global run_i
pset = gp.PrimitiveSetTyped("main", [array], float)
pset.addPrimitive(SMA, [array, int, int], float)
pset.addPrimitive(operator.add, [float, float], float)
pset.addPrimitive(part, [array, int], float)
pset.addPrimitive(shift, [array, int], float)
pset.addEphemeralConstant("randI{i}".format(i=run_i),
lambda: random.randint(0, n - 1), int)
pset.addEphemeralConstant("randF{i}".format(i=run_i),
lambda: random.uniform(-1, 1), float)
pset.addPrimitive(operator.sub, [float, float], float)
pset.addPrimitive(operator.mul, [float, float], float)
pset.addPrimitive(protectedDiv, [float, float], float)
pset.addPrimitive(IF2, [float, float, float, float], float)
run_i += 1
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
creator.create("Individual",
gp.PrimitiveTree,
fitness=creator.FitnessMax,
pset=pset)
toolbox.register("expr", genGrow_edit, pset=pset, min_=1, max_=15)
toolbox.register("individual", tools.initIterate, creator.Individual,
toolbox.expr)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("compile", gp.compile, pset=pset)
toolbox.register("evaluate", fitness_predictor, arg=errors, n=n)
toolbox.register("select", tools.selTournament, tournsize=tour)
toolbox.register("mate", gp.cxOnePointLeafBiased, termpb=termpb)
toolbox.register("expr_mut", genGrow_edit, min_=0, max_=5)
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))
#HISTORY
#HISTORY
#HISTORY
history = tools.History()
# Decorate the variation operators
toolbox.decorate("mate", history.decorator)
toolbox.decorate("mutate", history.decorator)
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)
if parallel == 1:
from scoop import futures
toolbox.register("map", futures.map) #PARALLELIZATION
elif parallel == 2:
import multiprocessing
pool = multiprocessing.Pool(6)
toolbox.register("map", pool.map) #PARALLELIZATION
pop = toolbox.population(n=popu)
#HISTORY
#HISTORY
#HISTORY
history.update(pop)
hof = tools.HallOfFame(1)
pop, log = algorithms.eaSimple(pop,
toolbox,
cxpb,
mutpb,
ngen,
stats=mstats,
halloffame=hof,
verbose=True)
# return hof[0].fitness.values[0] #FOR CMA-ES
# return log #FOR PLOT
return history #FOR HISTORY
def __init__(self, context):
# this is here for when you need to log for debugging
self.context = context
self.n_long_labels = 0
self.n_short_labels = 0
# len of hitory
self.n_features = 10 #
self.n_samples = 250
self.warmup_count = self.n_features + self.n_samples + 1
# persist the evolution, warning though you have to track when its run and on what data
try_load_saved_pop = False
# The primitive set defines what is possible in the program
self.pset = gp.PrimitiveSetTyped("MAIN", [float] * (self.n_features),
float)
self.pset.addPrimitive(operator.add, [float, float], float)
self.pset.addPrimitive(operator.sub, [float, float], float)
self.pset.addPrimitive(operator.mul, [float, float], float)
self.pset.addPrimitive(protectedDiv, [float, float], float)
self.pset.addPrimitive(operator.neg, [float], float)
self.pset.addPrimitive(operator.abs, [float], float)
self.pset.addPrimitive(np.hypot, [float, float], float)
self.pset.addPrimitive(np.absolute, [float], float)
self.pset.addPrimitive(np.fmax, [float, float], float)
self.pset.addPrimitive(np.fmin, [float, float], float)
self.pset.addPrimitive(np.sign, [float], float)
self.pset.addPrimitive(np.square, [float], float)
self.pset.addPrimitive(math.cos, [float], float)
self.pset.addPrimitive(math.sin, [float], float)
self.pset.addPrimitive(operator.and_, [BOOL, BOOL], BOOL)
self.pset.addPrimitive(operator.or_, [BOOL, BOOL], BOOL)
self.pset.addPrimitive(operator.not_, [BOOL], BOOL)
self.pset.addPrimitive(operator.lt, [float, float], BOOL)
self.pset.addPrimitive(operator.le, [float, float], BOOL)
self.pset.addPrimitive(operator.eq, [float, float], BOOL)
self.pset.addPrimitive(operator.ne, [float, float], BOOL)
self.pset.addPrimitive(operator.ge, [float, float], BOOL)
self.pset.addPrimitive(operator.gt, [float, float], BOOL)
self.pset.addPrimitive(if_then_else, [BOOL, float, float], float,
'ite_float')
self.pset.addPrimitive(if_then_else, [BOOL, BOOL, BOOL], BOOL,
'ite_bool')
self.pset.addEphemeralConstant("rand1", lambda: random.random(), float)
self.pset.addEphemeralConstant("rand-1", lambda: -random.random(),
float)
self.pset.addTerminal(-0.5, float)
self.pset.addTerminal(-1.0, float)
self.pset.addTerminal(0.0, float)
self.pset.addTerminal(0.5, float)
self.pset.addTerminal(1.0, float)
self.pset.addTerminal(False, BOOL)
self.pset.addTerminal(True, BOOL)
creator.create("FitnessMin", base.Fitness, weights=(-1.0, -1.0, -1.0))
creator.create("Individual",
gp.PrimitiveTree,
fitness=creator.FitnessMin)
self.toolbox = base.Toolbox()
self.toolbox.register("expr",
gp.genHalfAndHalf,
pset=self.pset,
min_=1,
max_=3)
self.toolbox.register("individual", tools.initIterate,
creator.Individual, self.toolbox.expr)
self.toolbox.register("population", tools.initRepeat, list,
self.toolbox.individual)
self.toolbox.register("compile", gp.compile, pset=self.pset)
self.toolbox.register("evaluate", self.evalSymbReg)
self.toolbox.register("select", tools.selNSGA2)
self.toolbox.register("mate", gp.cxOnePoint)
self.toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
self.toolbox.register("mutate",
gp.mutUniform,
expr=self.toolbox.expr_mut,
pset=self.pset)
self.toolbox.decorate("mate",
gp.staticLimit(key=operator.attrgetter("height"),
max_value=17)) #bloat control
self.toolbox.decorate("mutate",
gp.staticLimit(key=operator.attrgetter("height"),
max_value=17)) #bloat control
self.stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
self.stats_size = tools.Statistics(len)
self.stats = tools.MultiStatistics(fitness=self.stats_fit,
size=self.stats_size)
self.stats.register("avg", np.mean, axis=0)
self.stats.register("std", np.std, axis=0)
self.stats.register("min", np.min, axis=0)
self.stats.register("max", np.max, axis=0)
# persist the evolution, warning though you have to track when its run and on what data
checkpoint = 'checkpoint.pkl'
self.gen = 0
self.halloffame = tools.ParetoFront()
self.logbook = tools.Logbook()
self.logbook.header = ['gen', 'nevals'
] + (self.stats.fields if self.stats else [])
self.population = self.toolbox.population(n=n_pop)
self.selected_individuals = None
def main():
# Import data
x_train, y_train = load_split_all()[0]
x_test = load_split_all()[1][0]
# x_largest_in_each_col = np.max(x_train, axis=0)
# normalize(x_train, x_largest_in_each_col)
data = x_train
labels = y_train
num_positives = np.count_nonzero(labels)
num_negatives = len(labels) - num_positives
# num_positives is max false negatives
# num_negatives is max false positives - append these to fitness so we have reliable AuC
fn_trivial_fitness = (0, num_positives)
fp_trivial_fitness = (num_negatives, 0)
print(x_train.shape)
creator.create("FitnessMin", base.Fitness, weights=(-1.0, -1.0))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin)
# Arguments
random.seed(25)
crossover_rate = 0.5
mutation_rate = 0.2
samples = 10 # set to 10 when generating submission data
calc_area = True # set to true when generating submission data
input_types = []
for i in range(x_train.shape[1]): # multiplication op doesn't work
input_types.append(float)
pset = gp.PrimitiveSetTyped("MAIN", input_types, bool)
# Essential Primitives
pset.addPrimitive(is_greater, [float, float], bool)
pset.addPrimitive(is_equal_to, [float, float], bool)
pset.addPrimitive(if_then_else, [bool, float, float], float)
pset.addPrimitive(np.logical_not, [bool], bool)
pset.addPrimitive(
np.logical_and, [bool, bool],
bool) # Demorgan's rule says all logic ops can be made with not & and
pset.addPrimitive(np.negative, [float], float)
pset.addPrimitive(operator.mul, [float, float], float)
pset.addPrimitive(operator.add, [float, float], float)
pset.addPrimitive(operator.sub, [float, float], float)
# constants
# pset.addTerminal(2.0, float) # added
pset.addTerminal(10.0, float)
# pset.addTerminal(25.0, float) # added
pset.addTerminal(1, bool)
pset.addTerminal(0, bool)
# More primitives (for fun/tinkering/reducing verbosity of tree)
# Logic to float
# Float to logic
# Logic to logic
pset.addPrimitive(operator.xor, [bool, bool], bool)
# Float to float
pset.addPrimitive(relu, [float], float)
pset.addPrimitive(math.floor, [float], int)
# pset.addPrimitive(absolute, [float], float) # added
# pset.addPrimitive(safe_division, [float, float], float) # added
toolbox = base.Toolbox()
toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)
toolbox.register("individual", tools.initIterate, creator.Individual,
toolbox.expr)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("compile", gp.compile, pset=pset)
toolbox.register("evaluate",
evalSymbReg,
pset=pset,
data=data,
labels=labels)
# select
# toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("select",
sim_aneal_select,
tourn_size=25,
anneal_rate=0.6) # added
# crossover
toolbox.register("mate", gp.cxOnePoint)
# mutate
toolbox.register("expr_mut", gp.genFull, min_=1, max_=2)
toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset)
# toolbox.register("mutate", gp.mutNodeReplacement, pset=pset) # added
toolbox.decorate(
"mate", gp.staticLimit(key=operator.attrgetter("height"),
max_value=17))
toolbox.decorate(
"mutate",
gp.staticLimit(key=operator.attrgetter("height"), max_value=17))
gen = range(40)
avg_list = []
max_list = []
min_list = []
avg_areas = [
0 for g in gen
] # contains sum of performances per generation (averaged later)
best_pareto_front = (10**10, [])
for i in range(samples): # sample 10 times
# reset population at the start of each trial
pop = toolbox.population(n=300)
fitnesses = list(map(toolbox.evaluate, pop))
for ind, fit in zip(pop, fitnesses):
ind.fitness.values = fit
# Begin the evolution
for g in gen:
# Select the next generation individuals
offspring = toolbox.select(pop, len(pop))
# Clone the selected individuals
offspring = list(map(toolbox.clone, offspring))
# Apply crossover and mutation on the offspring
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < crossover_rate:
toolbox.mate(child1, child2)
del child1.fitness.values
del child2.fitness.values
for mutant in offspring:
if random.random() < mutation_rate:
toolbox.mutate(mutant)
del mutant.fitness.values
# Evaluate the individuals with an invalid fitness .... define invalid???
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitnesses = map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
# Replace population
pop[:] = offspring
# Gather all the fitnesses in one list and print the stats
fits = [ind.fitness.values[0] for ind in pop]
length = len(pop)
mean = sum(fits) / length
sum2 = sum(x * x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
g_max = max(fits)
g_min = min(fits)
avg_list.append(mean)
max_list.append(g_max)
min_list.append(g_min)
# print(" Min %s" % g_min)
# print(" Max %s" % g_max)
# print(" Avg %s" % mean)
# print(" Std %s" % std)
# find area under curve for population
if calc_area:
hof_pop = generate_min_front(pop)
# Extract fitnesses and sort so HoF draws correctly
hof = np.asarray([ind.fitness.values for ind in hof_pop])
hof = np.insert(hof, 0,
[fp_trivial_fitness, fn_trivial_fitness], 0)
hof = hof[np.argsort(hof[:, 0])]
area = area_under_curve(hof)
avg_areas[g] += area
info = "\t\tAUC: %f" % area
# update best pareto front
if area < best_pareto_front[0]:
scores = [ind.fitness.values for ind in hof_pop]
best_pareto_front = (area, hof_pop, scores)
else:
info = ""
print("-- Generation %i --%s" % (g, info))
print("-- End of (successful) evolution #%d of %d--" % (i, samples))
print("best AUC: %f" % best_pareto_front[0])
if calc_area:
# average the areas
avg_areas = [area / samples for area in avg_areas]
""" Don't write useless data
# write to csv
file = open("results/driver_results.csv", 'w')
header = ','
driver_line = "Driver,"
for g in gen:
header += "%d," % g
driver_line += "%f," % avg_areas[g]
header += "\n"
file.write(header)
file.write(driver_line)
file.close()"""
# write submission data
print("BEST AUC: %f" % best_pareto_front[0])
util.write_pareto_guesses("results/submission.csv", x_test, pset,
best_pareto_front[1], best_pareto_front[2])
hof_pop = generate_min_front(pop)
# Extract fitnesses and sort so HoF draws correctly
hof = np.asarray([ind.fitness.values for ind in hof_pop])
hof = np.insert(hof, 0, [fp_trivial_fitness, fn_trivial_fitness], 0)
hof = hof[np.argsort(hof[:, 0])]
# Charts
pop_1 = [ind.fitness.values[0] for ind in pop]
pop_2 = [ind.fitness.values[1] for ind in pop]
plt.scatter(pop_1, pop_2, color='b')
plt.scatter(hof[:, 0], hof[:, 1], color='r')
plt.plot(hof[:, 0], hof[:, 1], color='r', drawstyle='steps-post')
plt.xlabel("False Positives")
plt.ylabel("False Negatives")
plt.title("Pareto Front")
if calc_area:
print(avg_areas[-1])
else:
print(area_under_curve(hof))
plt.show()
if calc_area:
plt.plot(gen, avg_areas, color='g')
plt.xlabel("Generation")
plt.ylabel("Area Under Curve")
plt.title("AUC evolution")
plt.show()
import itertools
import numpy
from random import randint, getrandbits
from functools import reduce
from math import log
from deap import algorithms
from deap import base
from deap import creator
from deap import tools
from deap import gp
# defined a new primitive set for strongly typed GP
pset = gp.PrimitiveSetTyped("MAIN", (), list)
pset.addPrimitive(lambda l, e: l + [e], (list, int), list, name="append")
#pset.addPrimitive(operator.concat, (list, list), list)
pset.addPrimitive(lambda x: x, (int, ), int, name="id")
pset.addEphemeralConstant("rand10", lambda: randint(-50, +50), int)
pset.addTerminal([], list)
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_=2)
toolbox.register("individual", tools.initIterate, creator.Individual,
)] # Maybe make this a variable that is explored by the algorithm
dates = panda["Unnamed: 0"]
dict1 = dict(zip(dates, SO))
dict2 = dict(zip(dates, sig))
so = dict1[date]
sig1 = dict2[date]
ans = so - sig1 # Check this is the right way round. It may not matter.
return ans
def if_then_else(input, output1, output2):
return output1 if input else output2
# defined a new primitive set for strongly typed GP
pset = gp.PrimitiveSetTyped("MAIN", [str, position_bool], pd_bool)
# boolean operators
pset.addPrimitive(if_then_else, [position_bool, rsi_gt, rsi_lt], pd_bool)
pset.addPrimitive(operator.and_, [pd_bool, pd_bool], pd_bool)
pset.addPrimitive(operator.or_, [pd_bool, pd_bool], pd_bool)
pset.addPrimitive(operator.not_, [pd_bool], pd_bool)
pset.addPrimitive(operator.lt, [pd_float, pd_float], pd_bool)
pset.addPrimitive(operator.gt, [pd_float, pd_float], pd_bool)
pset.addPrimitive(operator.lt, [rsi_ans, rsi_bounds], rsi_lt)
pset.addPrimitive(operator.gt, [rsi_ans, rsi_bounds], rsi_gt)
pset.addPrimitive(
operator.lt, [macd_bounds, macd_ans], pd_bool
) # for above or below zero, maybe make macd_bounds and so_bounds the same thing
pset.addPrimitive(operator.gt, [macd_bounds, macd_ans], pd_bool)
pset.addPrimitive(operator.lt, [so_bounds, so_ans], pd_bool)
pset.addPrimitive(operator.gt, [so_bounds, so_ans], pd_bool)
# The dataset is from http://archive.ics.uci.edu/ml/datasets/Spambase
# This example is a copy of the OpenBEAGLE example :
# http://beagle.gel.ulaval.ca/refmanual/beagle/html/d2/dbe/group__Spambase.html
#with open("spambase/spambase.csv") as spambase:
# spamReader = csv.reader(spambase)
# spam = list(list(float(elem) for elem in row) for row in spamReader)
# defined a new primitive set for strongly typed GP
#pset = gp.PrimitiveSetTyped("MAIN", itertools.repeat(float, 10), bool)
class Vector(object):
pass
pset = gp.PrimitiveSetTyped("MAIN", (float, float, float, float, float, Vector,
Vector, Vector, Vector, Vector), bool)
#pset = gp.PrimitiveSetTyped("MAIN", itertools.repeat(float, 5), bool)
#pdb.set_trace()
# boolean operators
pset.addPrimitive(operator.and_, [bool, bool], bool)
pset.addPrimitive(operator.or_, [bool, bool], bool)
pset.addPrimitive(operator.not_, [bool], bool)
# floating point operators
# Define a protected division function
def protectedDiv(left, right):
try:
return left / right
from deap import base, creator, tools, algorithms, gp
import pickle
from gp_operators import *
# A definir: num_centroids, D2, max_depth, crossover_method, dump_filename, logistic_regression_mode
def generate_random_number():
return random.uniform(-1.0, 1.0)
def generate_random_tuple():
return D2 * (generate_random_number(), )
pset = gp.PrimitiveSetTyped("evo_doc2vec", num_centroids * [list], tuple, "x")
pset.addEphemeralConstant("k1", generate_random_number, float)
pset.addEphemeralConstant("k2", generate_random_tuple, tuple)
pset.addPrimitive(ident, D2 * [float], tuple)
pset.addPrimitive(ident_unit, D2 * [float], tuple)
pset.addPrimitive(ident_softmax, D2 * [float], tuple)
pset.addPrimitive(neg, [list], list)
pset.addPrimitive(add1, [list, list], list)
pset.addPrimitive(add2, [list, float], list)
pset.addPrimitive(sub1, [list, list], list)
pset.addPrimitive(sub2, [list, float], list)
pset.addPrimitive(mul1, [list, list], list)
pset.addPrimitive(mul2, [list, list], float)
pset.addPrimitive(mul3, [list, float], list)
def safeDiv(left,right):
if(right==0):
return 0
try:
return left/right
except ZeroDivisionError:
return 0
def clip2(num):
return np.clip(num,-1,1)
def end(inp1,inp2,inp3,inp4):
return [inp1,inp2,inp3,inp4]
pset = gp.PrimitiveSetTyped("MAIN", itertools.repeat(float,24),list,"ARG")
pset.addPrimitive(operator.add,[float,float],float)
pset.addPrimitive(operator.sub,[float,float],float)
pset.addPrimitive(operator.mul,[float,float],float)
pset.addPrimitive(safeDiv,[float,float],float)
pset.addPrimitive(operator.neg,[float],float)
pset.addPrimitive(math.cos,[float],float)
pset.addPrimitive(math.sin,[float],float)
pset.addPrimitive(sigmoid,[float],float)
pset.addPrimitive(relu,[float],float)
pset.addPrimitive(clip2,[float],float)
pset.addPrimitive(end,[float,float,float,float],list)
pset.addEphemeralConstant("rand101", lambda:random.randint(-1,1)*100,float)
pset.renameArguments(ARG0='hull_angle')
pset.renameArguments(ARG1='hull_angularVelocity')
pset = gp.PrimitiveSetTyped("MAIN", (), Ints)
##pset.addPrimitive(lambda x: return x, (Ints,), Ints)
#pset.addPrimitive(lambda x, y: Ints(x, y), (Ints, Ints), Ints)
#pset.addPrimitive(lambda x, y: Ints(x, y), (int, int), Ints)
#pset.addPrimitive(lambda x: Ints(x), (Int,), Ints)
#pset.addPrimitive(lambda x: Ints(x), (int,), Ints)
pset.addPrimitive(lambda x, y: Ints(x, y), (Ints, int), Ints, name='cons2')
pset.addPrimitive(lambda y: Ints(y), (int,), Ints, name='cons1')
pset.addEphemeralConstant("rand10", lambda: randint(0, 11), int)
"""
# defined a new primitive set for strongly typed GP
pset = gp.PrimitiveSetTyped("MAIN", (), int)
# boolop = And | Or
#pset.addPrimitive(operator.and_, (bool, bool), bool)
#pset.addPrimitive(operator.or_, (bool, bool), bool)
#operator = Add | Sub | Mult | Div | Mod | Pow | LShift
# | RShift | BitOr | BitXor | BitAnd | FloorDiv
pset.addPrimitive(operator.add, (int, int), int)
pset.addPrimitive(operator.sub, (int, int), int)
pset.addPrimitive(operator.mul, (int, int), int)
pset.addPrimitive(operator.floordiv, (int, int), int)
pset.addPrimitive(operator.mod, (int, int), int)
pset.addPrimitive(operator.lshift, (int, int), int)
pset.addPrimitive(operator.rshift, (int, int), int)
pset.addPrimitive(operator.xor, (int, int), int)
envs = [Enviroment() for i in range(6)]
agents_one = [None for i in range(6)]
agents_two = [Stable_defensive_agent(2) for i in range(6)]
funcs = [None for i in range(6)]
env1 = Enviroment()
env2 = Enviroment()
env3 = Enviroment()
agent1_two = Stable_defensive_agent(2)
agent2_two = Stable_defensive_agent(2)
agent3_two = Stable_defensive_agent(2)
semi_result = [0, 0, 0, 0, 0, 0, 0]
pset = gp.PrimitiveSetTyped("main", [int, int, int, int, int], ActionPlanEnum)
pset.addPrimitive(if_then_else, [Bool, ActionPlanEnum, ActionPlanEnum],
ActionPlanEnum)
pset.addPrimitive(compare, [int, int], Bool)
pset.addPrimitive(operator.mul, [int, int], int)
pset.addPrimitive(operator.add, [int, int], int)
pset.addTerminal(100, int)
pset.addTerminal(10, int)
pset.addTerminal(5, int)
pset.addTerminal(3, int)
pset.addTerminal(1, int)
pset.addTerminal(-1, int)
pset.addTerminal(0, int)
pset.addTerminal(ret_attack, ActionPlanEnum)
pset.addTerminal(ret_deffense, ActionPlanEnum)
pset.addTerminal(ret_evade, ActionPlanEnum)
