library: libTMVA #include "GeneticBase.h" |

viewCVS header - viewCVS source

Display options:

virtual | ~GeneticBase() |

Double_t | Calc() |

virtual Double_t | CalculateFitness() |

static TClass* | Class() |

Double_t | DoRenewFitness() |

virtual void | Evolution() |

void | Finalize() |

virtual Double_t | FitnessFunction(const vector<Double_t>& factors) |

TMVA::GeneticBase | GeneticBase() |

TMVA::GeneticBase | GeneticBase(Int_t populationSize, vector<TMVA::LowHigh_t*> ranges) |

TMVA::GeneticPopulation& | GetGeneticPopulation() |

Double_t | GetSpread() const |

virtual Bool_t | HasConverged(Int_t steps = 10, Double_t ratio = 0.1) |

void | Init() |

virtual TClass* | IsA() const |

virtual Double_t | NewFitness(Double_t oldValue, Double_t newValue) |

virtual Double_t | RenewFitness(vector<Double_t> factors, vector<Double_t> results) |

void | SetSpread(Double_t s) |

virtual void | ShowMembers(TMemberInspector& insp, char* parent) |

virtual Double_t | SpreadControl(Int_t steps, Int_t ofSteps, Double_t factor) |

virtual void | Streamer(TBuffer& b) |

void | StreamerNVirtual(TBuffer& b) |

TMVA::GeneticPopulation | fPopulation | contains and controls the "individual" |

Int_t | fConvCounter | converging? ... keeps track of the number of improvements |

Double_t | fConvValue | keeps track of the quantity of improvement |

deque<Int_t> | fSuccessList | to adjust the stepSize |

Double_t | fLastResult | remembers the last obtained result (for internal use) |

Double_t | fSpread | regulates the spread of the value change at mutation (sigma) |

Bool_t | fMirror | new values for mutation are mirror-mapped if outside of constraints |

Bool_t | fSexual | allow sexual recombination of individual |

Bool_t | fFirstTime | if true its the first time, so no evolution yet |

TMVA::MsgLogger | fLogger | message logger |

Base definition for genetic algorithm _______________________________________________________________________

GeneticBase( Int_t populationSize, vector<LowHigh_t*> ranges )

Constructor Parameters: int populationSize : defines the number of "Individuals" which are created and tested within one Generation (Iteration of the Evolution) vector<LowHigh_t*> ranges : LowHigh_t is a pair of doubles, where the first entry is the low and the second entry the high constraint of the variable the size of "ranges" is the number of coefficients which are optimised Purpose: Creates a random population with individuals of the size ranges.size()

void Init()

calls evolution, but if it is not the first time. If it's the first time, the random population created by the constructor is still not evaluated, .. therefore we wait for the second time init is called.

Double_t FitnessFunction( const std::vector< Double_t > & /* factors */)

the "fitnessFunction" this function is designed to be overridden. when overridden it should give back a (double) value which tells the "fitness" (= quality) of the result. This might be a resolution, a distance, ... Parameter: vector< double > factors : the factors are given by the Genetic Algorithm. These are the factors that have to be tested to assess its quality.

Double_t NewFitness( Double_t /*oldValue*/, Double_t newValue )

if the "fitnessFunction" is called multiple times for one set of factors (because i.e. each event of a TTree has to be assessed with each set of Factors proposed by the Genetic Algorithm) the value of the current calculation has to be added(? or else) to the value obtained up to now. example: some chi-square is calculated for every event, after every event the new chi-square (newValue) has to be simply added to the oldValue. this function has to be overridden eventually it might contain only the following return statement. return oldValue + newValue;

Double_t CalculateFitness()

```
starts the evaluation of the fitness of all different individuals of
the population.
this function calls implicitly (many times) the "fitnessFunction" which
has been overridden by the user.
```

Double_t DoRenewFitness()

the fitness values of every individual is stored .. if the fitness has been evaluated for many events, all the results are internally stored. this function allows to loop through all results of all individuals. it calls implicitly the function "renewFitness" the right place to call this function would be at the end of one "Generation" to set the fitness of every individual new depending on all the results it obtained in this generation.

Double_t RenewFitness( vector<Double_t> /*factors*/, vector<Double_t> /* results */)

this function has to be overridden if "doRenewFitness" is called Parameters: vector< double > factors : in this vector the factors of a specific individual are given. vector< double > results : in this vector the results obtained by the given coefficients are given. out of this information (the quality of the results) a new? value for the quality (fitness) of the set of factors has to be given back.

void Evolution()

```
this function is called from "init" and controls the evolution of the
individuals.
the function can be overridden to change the parameters for mutation rate
sexual reproduction and so on.
```

Double_t SpreadControl( Int_t ofSteps, Int_t successSteps, Double_t factor )

this function provides the ability to change the stepSize of a mutation according to the success of the last generations. Parameters: int ofSteps : = if OF the number of STEPS given in this variable (ofSteps) int successSteps : >sucessSteps Generations could improve the result double factor : than multiply the stepSize ( spread ) by this factor (if ofSteps == successSteps nothing is changed, if ofSteps < successSteps, the spread is divided by the factor) using this function one can increase the stepSize of the mutation when we have good success (to pass fast through the easy phase-space) and reduce the stepSize if we are in a difficult "territory" of the phase-space.

Bool_t HasConverged( Int_t steps, Double_t improvement )

gives back true if the last "steps" steps have lead to an improvement of the "fitness" of the "individuals" of at least "improvement" this gives a simple measure of if the fitness of the individuals is converging and no major improvement is to be expected soon.