Optimizers

Optimizers are used in conjugation with single generation worlds (or within multi-generation worlds). Optimizers take a population and use results of the evaluations performed by worlds to select parents which are used to generate a new population. Depending on the type of optimizer being used, the new generation may be all new organisms or a mix of new organisms and organisms from previous generations.

optimizeValue

each optimizer will define parameters which determine what values will be optimized. Most commonly, this parameter will be called 'optimizeValue'. Optimizers may be created that optimize on more than one term (i.e. multi-objective) and these optimizers will define parameters as needed.

Optimizers will usually use an MTree for the optimizeValue parameter. This allows the user to determine what elements from organisms DataMaps will be used and how.

Asexual vs. Sexual Reproduction

Asexual optimizers generate offspring from a single parent. Sexual optimizers select two or more parents and generate offspring from these. In either case, in the code, generally, this is handled with a call to makeMutatedOffspringFrom() when there is only a single parent or makeMutatedOffspringFromMany() when there is more than one parent. Both of these functions manage the process of generating child organisms, as well as performing recombination, mutations, constructing new brains, etc. based on the type of genomes and brains being used.

Optimizer Types

SIMPLE

This is the default optimizer and provides some basic functionality and flexibility.

% OPTIMIZER_SIMPLE
  elitismCount = 1                           # (string) number of mutated offspring added to next population for each elite organism (MTree)
  elitismRange = 0                           # (string) number of elite organisms (i.e. if 5, then best 5) (MTree)
  numberParents = 1                          # (int) number of parents used to produce offspring
  optimizeValue = POW[1.05,DM_AVE[score]]    # (string) value to optimize (MTree)
  selectionMethod = Roulette()               # (string) how are parents selected? options: Roulette(),Tournament(size=SIZE)
  selfRate = 0                               # (string) value between 0 and 1, likelihood that an organism will survive (MTree)
  surviveRate = 0                            # (string) value between 0 and 1, likelihood that an organism will self (ignored if numberParents = 1) (MTree)

• elitismCount and elitismRange determine if there will be elitism (i.e. are the best organisms guaranteed to produce offspring) the elitimRange determines how many organisms will be considered elites (i.e. 3 would indicate the 3 best) and elitismCount determines how many offspring each of the elites is guaranteed (they may have more, if they are selected as a parent later). Note that offspring produced by elitism in SimpleOptimizer always have one parent (even if numberParents is set to a different value)
• numberParents sets the number of parents which will be used to produce offspring. All parents will be selected by the same method. It is possible that two or more parents of an offspring are the same organism.
• optimizeValue defines the value that will be associated with each organism and used by the selectionMethod to select parents. optimizeValue is an MTree which means that you can set this parameter with a formula which can consider values from an organisms DataMaps, parameters and the current update. click here for more on MTree
• selectionMethod determins how parents are selected:
  • Roulette - in order to select parents, the roulette method uses a proportional selection method where an organisms relitive optimizeValue to the rest of the population determines it's probabilty to mate.
  • Tournament - in order to select parents, the tournament method repeatady randomly generates groups of organisms (containing SIZE organisms) and selects the organism from that group with the highest optimizeValue.
  • optimizeValue defines the value that will be associated with each organism and used by the selectionMethod to select parents. optimizeValue is an MTree which means that you can set this parameter with a formula which can consider values from an organsims DataMaps, parameters and the current update. click here for more on MTree
  Tournament
  Selects a single parent organism at a time and then calls makeMutatedOffspringFrom() with this organism to produce a new organism which is added to a new population. To select each parent organism a number of organisms are selected at random from the population. From this selection, the organism with the highest score is used as the parent.
  Tournament2
  Selects a two parent organisms at a time and then calls makeMutatedOffspringFromMany() with these organisms to produce a new organism which is added to a new population. Although this is sexual reproduction, the gender of the organisms is ignored. The two parents are picked using the method defined in Tournament.
  (variableMethod)
  not implemented yet - selects one parent and then inspects that parents genome to determine if this parent will reproduce sexually or asexually and if sexually, which sexual trait will be used.
  (multi objective)
  not implemented yet
  (lambda lambda)
  not implemented yet