selfadaptivesystemmultiobjective.params

parent.0 = spea2.params
#parent.0 = nsga2.params
parent.1 = koza.params


#pop.subpop.0 = ec.multiobjective.spea2.SPEA2Subpopulation
pop.subpop.0.size = 1000
pop.subpop.0.archive-size= 50

eval = ec.multiobjective.spea2.SPEA2Evaluator
breed = ec.multiobjective.spea2.SPEA2Breeder

# the multiobjective stuff
#objective string - put the letters in the order you want the objectives evaluated
#then make sure the num-objectives below match the number of parameters listed
#and the fitness min and max values below also match the ranges for the 
#objective in that postition
#objectives codes: 
#t - time to complete plan
#n - number of servers active at the end of the plan
#c - cost per second at the end of the plan
#r - responses handled by the system per second at the end of the plan
#d - dimmed responses handled at the end of the plan
#f - non-dimmed responses handled at the end of the plan
#i - gross income of the system configuration at the end of the plan
#p - profit
#q - quality, num normal users / num total users
#a - latency 1 / (handleable - incoming)
#s - penalizing same trees on both sides of an if then (meaning if 
 	the action succeeds or fails still do the same thing) this is 
 	the number that occur
#l - minimize plan length
#example objective string: rql - evaluate based on response time, quality, and plan length 
 
objectives=pa


# you can also assign this on a per-subpopulation basis
multi.fitness.num-objectives 	= 2

# max and min values of all each objective function
multi.fitness.max 		= 100000
multi.fitness.min 		= 0

# override specific max and min values, e.g
#multi.fitness.max.1		= 1
#multi.fitness.min.1     = 0

multi.fitness.min.1 = 0
multi.fitness.max.1 = 10000

# minimize 3 objectives
pop.subpop.0.species.fitness.maximize.0 = true
pop.subpop.0.species.fitness.maximize.1 = false
pop.subpop.0.species.fitness.maximize.2 = false
pop.subpop.0.species.fitness.maximize.3 = false
pop.subpop.0.species.fitness.maximize.4 = false
pop.subpop.0.species.fitness.maximize.5 = true
pop.subpop.0.species.fitness.maximize.6 = true
pop.subpop.0.species.fitness.maximize.7 = false
pop.subpop.0.species.fitness.maximize.8 = true
pop.subpop.0.species.fitness.maximize.9 = false

# the next four items are already defined in koza.params, but we
# put them here to be clear.

# We have one function set, of class GPFunctionSet
gp.fs.size = 1
gp.fs.0 = ec.gp.GPFunctionSet
# We'll call the function set "f0".
gp.fs.0.name = f0

# We have these functions in the function set.  They are:
gp.fs.0.size = 13
gp.fs.0.func.0 = ecj.operators.TryCatchFinally
gp.fs.0.func.0.nc = nc3
gp.fs.0.func.1 = ecj.operators.SequenceOperator
gp.fs.0.func.1.nc = nc2
gp.fs.0.func.2 = ecj.actions.StartNewServer
gp.fs.0.func.2.nc = nc1
gp.fs.0.func.3 = ecj.actions.IncreaseDimmerLevel
gp.fs.0.func.3.nc = nc1
gp.fs.0.func.4 = ecj.actions.DecreaseDimmerLevel
gp.fs.0.func.4.nc = nc1
gp.fs.0.func.5 = ecj.actions.IncreaseTrafficLevel
gp.fs.0.func.5.nc = nc1
gp.fs.0.func.6 = ecj.actions.DecreaseTrafficLevel
gp.fs.0.func.6.nc = nc1
gp.fs.0.func.7 = ecj.actions.ShutdownServerNode
gp.fs.0.func.7.nc = nc1
gp.fs.0.func.8 = ecj.actions.ServerA
gp.fs.0.func.8.nc = nc0
gp.fs.0.func.9 = ecj.actions.ServerB
gp.fs.0.func.9.nc = nc0
gp.fs.0.func.10 = ecj.actions.ServerC
gp.fs.0.func.10.nc = nc0
gp.fs.0.func.11 = ecj.operators.For
gp.fs.0.func.11.nc = nc4
gp.fs.0.func.12 = ecj.operators.ForIndex
gp.fs.0.func.12.nc = nc5
gp.fs.0.func.13 = ecj.actions.ServerD
gp.fs.0.func.13.nc = nc0
gp.fs.0.func.14 = ecj.operators.Retry
gp.fs.0.func.14.nc = nc6


# Here we define a single atomic type, "nil", which everyone will use.
# There are no set types defined.

gp.type.a.size = 3
gp.type.a.0.name = server
gp.type.a.1.name = plan
gp.type.a.2.name = int
gp.type.s.size = 0

# Here we define one GPTreeConstraints object, "tc0",
# which uses ec.gp.koza.HalfBuilder to create nodes,
# only allows nodes from the GPFunctionSet "fset",
# and has the single type "nil" as its tree type.
# You don't need to include the class declaration here,
# but it quiets warnings.

gp.tc.size = 1
gp.tc.0 = ec.gp.GPTreeConstraints
gp.tc.0.name = tc0
gp.tc.0.fset = f0
gp.tc.0.returns = plan

# Here we define 7 GPNodeConstraints, nc0...nc6, which
# describe nodes with 0...6 children respectively, which only
# use a single type, "nil", for their argument and return types
# You don't need to include the class declarations with everything
# else below, but it quiets warnings

gp.nc.size = 7

gp.nc.0 = ec.gp.GPNodeConstraints
gp.nc.0.name = nc0
gp.nc.0.returns = server
gp.nc.0.size = 0

gp.nc.1 = ec.gp.GPNodeConstraints
gp.nc.1.name = nc1
gp.nc.1.returns = plan
gp.nc.1.size = 1
gp.nc.1.child.0 = server

gp.nc.2 = ec.gp.GPNodeConstraints
gp.nc.2.name = nc2
gp.nc.2.returns = plan
gp.nc.2.size = 2
gp.nc.2.child.0 = plan
gp.nc.2.child.1 = plan

gp.nc.3 = ec.gp.GPNodeConstraints
gp.nc.3.name = nc3
gp.nc.3.returns = plan
gp.nc.3.size = 3
gp.nc.3.child.0 = plan
gp.nc.3.child.1 = plan
gp.nc.3.child.2 = plan

gp.nc.4 = ec.gp.GPNodeConstraints
gp.nc.4.name = nc4
gp.nc.4.returns = plan
gp.nc.4.size = 2
gp.nc.4.child.0 = int
gp.nc.4.child.1 = plan

gp.nc.5 = ec.gp.GPNodeConstraints
gp.nc.5.name = nc5
gp.nc.5.returns = int
gp.nc.5.size = 0

gp.nc.6 = ec.gp.GPNodeConstraints
gp.nc.6.name = nc6
gp.nc.6.returns = plan
gp.nc.6.size = 1
gp.nc.6.child.0 = plan

gp.koza.xover.maxdepth = 10
gp.koza.mutate.maxdepth = 10
gp.koza.grow.min-depth = 1
gp.koza.grow.max-depth = 10
gp.koza.half.min-depth = 1
gp.koza.half.max-depth = 5

#gp.koza.xover.maxdepth = 6
#gp.koza.mutate.maxdepth = 6
#gp.koza.grow.min-depth = 6
#gp.koza.grow.max-depth = 6
#gp.koza.half.min-depth = 6
#gp.koza.half.max-depth = 6

eval.problem = ecj.OmnetProblemMulti
eval.problem.data = ecj.StateData
generations = 100
pop.subpop.0.size =	1000

#allow ECJ to figure out the number of cores
breedthreads = 1
evalthreads = 8

#print-params = true

# copy a bunch of stuff from zack + joannas file and hoping that it works
pop.subpop.0.species = ec.vector.FloatVectorSpecies
pop.subpop.0.species.ind = ec.vector.DoubleVectorIndividual

seed.0 = 123456789
seed.1 = 123456788
seed.2 = 123456787
seed.3 = 123456786
seed.4 = 123456785
seed.5 = 123456784
seed.6 = 123456783
seed.7 = 123456782

eval.problem.stack = ec.gp.ADFStack
eval.problem.stack.context = ec.gp.ADFContext

#copied from koza.params

pop.subpop.0.species = ec.gp.GPSpecies
pop.subpop.0.species.ind = ec.gp.GPIndividual
pop.subpop.0.species.ind.numtrees = 1
pop.subpop.0.species.ind.tree.0 = ec.gp.GPTree
pop.subpop.0.species.ind.tree.0.tc = tc0
init = ec.gp.GPInitializer
gp.tc.size = 1
gp.tc.0 = ec.gp.GPTreeConstraints
gp.tc.0.name = tc0
gp.tc.0.fset = f0
gp.tc.0.returns = plan
gp.tc.0.init = ec.gp.koza.HalfBuilder
# We set the default for HalfBuilder to be a ramp of 2--6,
# with a grow probability of 0.5
gp.koza.half.min-depth = 2
gp.koza.half.max-depth = 5
gp.koza.half.growp = 0.5

gp.nc.size = 7

pop.subpop.0.species.pipe = ec.breed.MultiBreedingPipeline
# Koza's decision here was odd...
pop.subpop.0.species.pipe.generate-max = false
# Subsidiary pipelines:
pop.subpop.0.species.pipe.num-sources = 3
pop.subpop.0.species.pipe.source.0 = ec.gp.koza.CrossoverPipeline
pop.subpop.0.species.pipe.source.0.prob = 0.6
pop.subpop.0.species.pipe.source.1 = ec.breed.ReproductionPipeline
pop.subpop.0.species.pipe.source.1.prob = 0.2
pop.subpop.0.species.pipe.source.2 = ec.gp.koza.MutationPipeline
pop.subpop.0.species.pipe.source.2.prob = 0.2

# Reproduction will use Tournament Selection 
breed.reproduce.source.0 = ec.multiobjective.spea2.SPEA2TournamentSelection

# Crossover will use Tournament Selection, try only 1
# time, have a max depth of 10, and use KozaNodeSelector
gp.koza.xover.source.0 = ec.multiobjective.spea2.SPEA2TournamentSelection
gp.koza.xover.source.1 = same
gp.koza.xover.ns.0 = ec.gp.koza.KozaNodeSelector
gp.koza.xover.ns.1 = same
gp.koza.xover.maxdepth = 10
# This is the default for Koza and lil-gp, though it's
# a little wimpy; on the other hand, a higher number can
# make things really slow
gp.koza.xover.tries = 1

# Point Mutation will use Tournament Selection, try only 1
# time, have a max depth of 17, and use KozaNodeSelector
# and GROW for building.  Also, Point Mutation uses a GrowBuilder
# by default, with a default of min-depth=max-depth=5
# as shown a ways below
gp.koza.mutate.source.0 = ec.multiobjective.spea2.SPEA2TournamentSelection
gp.koza.mutate.ns.0 = ec.gp.koza.KozaNodeSelector
gp.koza.mutate.build.0 = ec.gp.koza.GrowBuilder
gp.koza.mutate.maxdepth = 17
# This is the default for Koza and lil-gp, though it's
# a little wimpy; on the other hand, a higher number can
# make things really slow
gp.koza.mutate.tries = 1

#
# The default tournament size for TournamentSelection is 7
#

select.tournament.size = 7

# Since GROW is only used for subtree mutation, ECJ uses
# the Koza-standard subtree mutation GROW values for the
# default for GROW as a whole.  This default is
# min-depth=max-depth=5, which I don't like very much,
# but hey, that's the standard.  
# This means that if someone decided to use GROW to generate
# new individual trees, it's also use the defaults below
# unless he overrided them locally.
gp.koza.grow.min-depth = 1
gp.koza.grow.max-depth = 10

#gp.tc.0.init = ec.gp.koza.HalfBuilder
gp.tc.0.init = ecj.MutationBuilder

#come back and adjust this later when you know exactly what you need
gp.koza.initmutate.ns = ec.gp.koza.KozaNodeSelector
gp.koza.initmutate.build = ec.gp.koza.GrowBuilder
gp.koza.initmutate.maxdepth = 10
gp.koza.initmutate.tries = 1

invalid_action_penalty = 0
verboseness_penalty = 0.01
min_accepted_improvement = 0.000
stat =                                          ec.multiobjective.MultiObjectiveStatistics
#stat =                                          ecj.CustomMultiStats
stat.front =                                    $front.stat