Logo ROOT  
Reference Guide
GeneticPopulation.cxx
Go to the documentation of this file.
1 // @(#)root/tmva $Id$
2 // Author: Peter Speckmayer
3 
4 /**********************************************************************************
5  * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
6  * Package: TMVA *
7  * Class : TMVA::GeneticPopulation *
8  * Web : http://tmva.sourceforge.net *
9  * *
10  * Description: *
11  * Implementation (see header for description) *
12  * *
13  * Authors (alphabetical): *
14  * Peter Speckmayer <speckmay@mail.cern.ch> - CERN, Switzerland *
15  * *
16  * Copyright (c) 2005: *
17  * CERN, Switzerland *
18  * MPI-K Heidelberg, Germany *
19  * *
20  * Redistribution and use in source and binary forms, with or without *
21  * modification, are permitted according to the terms listed in LICENSE *
22  * (http://tmva.sourceforge.net/LICENSE) *
23  **********************************************************************************/
24 
25 /*! \class TMVA::GeneticPopulation
26 \ingroup TMVA
27 
28 Population definition for genetic algorithm.
29 
30 */
31 
32 #include <algorithm>
33 
34 #include "Rstrstream.h"
35 #include "TRandom3.h"
36 #include "TH1.h"
37 
38 #include "TMVA/GeneticPopulation.h"
39 #include "TMVA/GeneticGenes.h"
40 #include "TMVA/MsgLogger.h"
41 
43 
44 using namespace std;
45 
46 ////////////////////////////////////////////////////////////////////////////////
47 /// Constructor
48 
49 TMVA::GeneticPopulation::GeneticPopulation(const std::vector<Interval*>& ranges, Int_t size, UInt_t seed)
50  : fGenePool(size),
51  fRanges(ranges.size()),
52  fLogger( new MsgLogger("GeneticPopulation") )
53 {
54  // create a randomGenerator for this population and set a seed
55  // create the genePools
56  //
57  fRandomGenerator = new TRandom3( 100 ); //please check
58  fRandomGenerator->Uniform(0.,1.);
59  fRandomGenerator->SetSeed( seed );
60 
61  for ( unsigned int i = 0; i < ranges.size(); ++i )
62  fRanges[i] = new TMVA::GeneticRange( fRandomGenerator, ranges[i] );
63 
64  vector<Double_t> newEntry( fRanges.size() );
65  for ( int i = 0; i < size; ++i )
66  {
67  for ( unsigned int rIt = 0; rIt < fRanges.size(); ++rIt )
68  newEntry[rIt] = fRanges[rIt]->Random();
69  fGenePool[i] = TMVA::GeneticGenes( newEntry);
70  }
71 
72  fPopulationSizeLimit = size;
73 }
74 
75 ////////////////////////////////////////////////////////////////////////////////
76 /// destructor
77 
79 {
80  if (fRandomGenerator != NULL) delete fRandomGenerator;
81 
82  std::vector<GeneticRange*>::iterator it = fRanges.begin();
83  for (;it!=fRanges.end(); ++it) delete *it;
84 
85  delete fLogger;
86 }
87 
88 
89 
90 ////////////////////////////////////////////////////////////////////////////////
91 /// the random seed of the random generator
92 
94 {
95  fRandomGenerator->SetSeed( seed );
96 }
97 
98 ////////////////////////////////////////////////////////////////////////////////
99 /// Produces offspring which is are copies of their parents.
100 ///
101 /// Parameters:
102 /// - int number : the number of the last individual to be copied
103 
105 {
106  int i=0;
107  for (std::vector<TMVA::GeneticGenes>::iterator it = fGenePool.begin();
108  it != fGenePool.end() && i < number;
109  ++it, ++i ) {
110  GiveHint( it->GetFactors(), it->GetFitness() );
111  }
112 }
113 
114 ////////////////////////////////////////////////////////////////////////////////
115 /// Creates children out of members of the current generation.
116 ///
117 /// Children have a combination of the coefficients of their parents
118 
120 {
121 #ifdef _GLIBCXX_PARALLEL
122 #pragma omp parallel
123 #pragma omp for
124 #endif
125  for ( int it = 0; it < (int) (fGenePool.size() / 2); ++it )
126  {
127  Int_t pos = (Int_t)fRandomGenerator->Integer( fGenePool.size()/2 );
128  fGenePool[(fGenePool.size() / 2) + it] = MakeSex( fGenePool[it], fGenePool[pos] );
129  }
130 }
131 
132 ////////////////////////////////////////////////////////////////////////////////
133 /// this function takes two individuals and produces offspring by mixing
134 /// (recombining) their coefficients.
135 
137  TMVA::GeneticGenes female )
138 {
139  vector< Double_t > child(fRanges.size());
140  for (unsigned int i = 0; i < fRanges.size(); ++i) {
141  if (fRandomGenerator->Integer( 2 ) == 0) {
142  child[i] = male.GetFactors()[i];
143  }else{
144  child[i] = female.GetFactors()[i];
145  }
146  }
147  return TMVA::GeneticGenes( child );
148 }
149 
150 ////////////////////////////////////////////////////////////////////////////////
151 /// Mutates the individuals in the genePool.
152 ///
153 /// Parameters:
154 ///
155 /// - double probability : gives the probability (in percent) of a mutation of a coefficient
156 /// - int startIndex : leaves unchanged (without mutation) the individuals which are better ranked
157 /// than indicated by "startIndex". This means: if "startIndex==3", the first (and best)
158 /// three individuals are not mutated. This allows to preserve the best result of the
159 /// current Generation for the next generation.
160 /// - Bool_t near : if true, the mutation will produce a new coefficient which is "near" the old one
161 /// (gaussian around the current value)
162 /// - double spread : if near==true, spread gives the sigma of the gaussian
163 /// - Bool_t mirror : if the new value obtained would be outside of the given constraints
164 /// the value is mapped between the constraints again. This can be done either
165 /// by a kind of periodic boundary conditions or mirrored at the boundary.
166 /// (mirror = true seems more "natural")
167 
168 void TMVA::GeneticPopulation::Mutate( Double_t probability , Int_t startIndex,
169  Bool_t near, Double_t spread, Bool_t mirror )
170 {
171  vector< Double_t>::iterator vec;
172  vector< TMVA::GeneticRange* >::iterator vecRange;
173 
174  //#ifdef _GLIBCXX_PARALLEL
175  // #pragma omp parallel
176  // #pragma omp for
177  //#endif
178  // The range methods are not thread safe!
179  for (int it = startIndex; it < (int) fGenePool.size(); ++it) {
180  vecRange = fRanges.begin();
181  for (vec = (fGenePool[it].GetFactors()).begin(); vec < (fGenePool[it].GetFactors()).end(); ++vec) {
182  if (fRandomGenerator->Uniform( 100 ) <= probability) {
183  (*vec) = (*vecRange)->Random( near, (*vec), spread, mirror );
184  }
185  ++vecRange;
186  }
187  }
188 }
189 
190 
191 ////////////////////////////////////////////////////////////////////////////////
192 /// gives back the "Genes" of the population with the given index.
193 
195 {
196  return &(fGenePool[index]);
197 }
198 
199 ////////////////////////////////////////////////////////////////////////////////
200 /// make a little printout of the individuals up to index "untilIndex"
201 /// this means, .. write out the best "untilIndex" individuals.
202 
204 {
205  for ( unsigned int it = 0; it < fGenePool.size(); ++it )
206  {
207  Int_t n=0;
208  if (untilIndex >= -1 ) {
209  if (untilIndex == -1 ) return;
210  untilIndex--;
211  }
212  Log() << "fitness: " << fGenePool[it].GetFitness() << " ";
213  for (vector< Double_t >::iterator vec = fGenePool[it].GetFactors().begin();
214  vec < fGenePool[it].GetFactors().end(); ++vec ) {
215  Log() << "f_" << n++ << ": " << (*vec) << " ";
216  }
217  Log() << Endl;
218  }
219 }
220 
221 ////////////////////////////////////////////////////////////////////////////////
222 /// make a little printout to the stream "out" of the individuals up to index "untilIndex"
223 /// this means, .. write out the best "untilIndex" individuals.
224 
225 void TMVA::GeneticPopulation::Print( ostream & out, Int_t untilIndex )
226 {
227  for ( unsigned int it = 0; it < fGenePool.size(); ++it ) {
228  Int_t n=0;
229  if (untilIndex >= -1 ) {
230  if (untilIndex == -1 ) return;
231  untilIndex--;
232  }
233  out << "fitness: " << fGenePool[it].GetFitness() << " ";
234  for (vector< Double_t >::iterator vec = fGenePool[it].GetFactors().begin();
235  vec < fGenePool[it].GetFactors().end(); ++vec ) {
236  out << "f_" << n++ << ": " << (*vec) << " ";
237  }
238  out << std::endl;
239  }
240 }
241 
242 ////////////////////////////////////////////////////////////////////////////////
243 /// give back a histogram with the distribution of the coefficients.
244 ///
245 /// Parameters:
246 ///
247 /// - int bins : number of bins of the histogram
248 /// - int min : histogram minimum
249 /// - int max : maximum value of the histogram
250 
252  Int_t min, Int_t max )
253 {
254  std::cout << "FAILED! TMVA::GeneticPopulation::VariableDistribution" << std::endl;
255 
256  std::stringstream histName;
257  histName.clear();
258  histName.str("v");
259  histName << varNumber;
260  TH1F *hist = new TH1F( histName.str().c_str(),histName.str().c_str(), bins,min,max );
261 
262  return hist;
263 }
264 
265 ////////////////////////////////////////////////////////////////////////////////
266 /// gives back all the values of coefficient "varNumber" of the current generation
267 
268 vector<Double_t> TMVA::GeneticPopulation::VariableDistribution( Int_t /*varNumber*/ )
269 {
270  std::cout << "FAILED! TMVA::GeneticPopulation::VariableDistribution" << std::endl;
271 
272  vector< Double_t > varDist;
273 
274  return varDist;
275 }
276 
277 ////////////////////////////////////////////////////////////////////////////////
278 /// add another population (strangers) to the one of this GeneticPopulation
279 
281 {
282  for (std::vector<TMVA::GeneticGenes>::iterator it = strangers->fGenePool.begin();
283  it != strangers->fGenePool.end(); ++it ) {
284  GiveHint( it->GetFactors(), it->GetFitness() );
285  }
286 }
287 
288 ////////////////////////////////////////////////////////////////////////////////
289 /// add another population (strangers) to the one of this GeneticPopulation
290 
292 {
293  AddPopulation(&strangers);
294 }
295 
296 ////////////////////////////////////////////////////////////////////////////////
297 /// trim the population to the predefined size
298 
300 {
301  std::sort(fGenePool.begin(), fGenePool.end());
302  while ( fGenePool.size() > (unsigned int) fPopulationSizeLimit )
303  fGenePool.pop_back();
304 }
305 
306 ////////////////////////////////////////////////////////////////////////////////
307 /// add an individual (a set of variables) to the population
308 /// if there is a set of variables which is known to perform good, they can be given as a hint to the population
309 
310 void TMVA::GeneticPopulation::GiveHint( std::vector< Double_t >& hint, Double_t fitness )
311 {
312  TMVA::GeneticGenes g(hint);
313  g.SetFitness(fitness);
314 
315  fGenePool.push_back( g );
316 }
317 
318 ////////////////////////////////////////////////////////////////////////////////
319 /// sort the genepool according to the fitness of the individuals
320 
322 {
323  std::sort(fGenePool.begin(), fGenePool.end());
324 }
325 
TMVA::GeneticPopulation::AddPopulation
void AddPopulation(GeneticPopulation *strangers)
add another population (strangers) to the one of this GeneticPopulation
Definition: GeneticPopulation.cxx:280
n
const Int_t n
Definition: legend1.C:16
Rstrstream.h
GeneticPopulation.h
TMVA::GeneticPopulation::SetRandomSeed
void SetRandomSeed(UInt_t seed=0)
the random seed of the random generator
Definition: GeneticPopulation.cxx:93
GeneticGenes.h
TMVA::GeneticPopulation::TrimPopulation
void TrimPopulation()
trim the population to the predefined size
Definition: GeneticPopulation.cxx:299
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TMath::Log
Double_t Log(Double_t x)
Definition: TMath.h:760
TMVA::GeneticRange
Range definition for genetic algorithm.
Definition: GeneticRange.h:42
Int_t
int Int_t
Definition: RtypesCore.h:45
TRandom::Uniform
virtual Double_t Uniform(Double_t x1=1)
Returns a uniform deviate on the interval (0, x1).
Definition: TRandom.cxx:672
TMVA::GeneticPopulation::MakeChildren
void MakeChildren()
Creates children out of members of the current generation.
Definition: GeneticPopulation.cxx:119
TMVA::GeneticPopulation::fGenePool
std::vector< TMVA::GeneticGenes > fGenePool
Definition: GeneticPopulation.h:94
TMVA::GeneticPopulation::VariableDistribution
TH1F * VariableDistribution(Int_t varNumber, Int_t bins, Int_t min, Int_t max)
give back a histogram with the distribution of the coefficients.
Definition: GeneticPopulation.cxx:251
TMVA::GeneticPopulation::MakeSex
GeneticGenes MakeSex(GeneticGenes male, GeneticGenes female)
this function takes two individuals and produces offspring by mixing (recombining) their coefficients...
Definition: GeneticPopulation.cxx:136
bool
TMVA::GeneticPopulation::GeneticPopulation
GeneticPopulation(const std::vector< TMVA::Interval * > &ranges, Int_t size, UInt_t seed=0)
Constructor.
Definition: GeneticPopulation.cxx:49
TMVA::GeneticPopulation::fRanges
std::vector< TMVA::GeneticRange * > fRanges
Definition: GeneticPopulation.h:95
TMVA::GeneticPopulation::fRandomGenerator
TRandom3 * fRandomGenerator
Definition: GeneticPopulation.h:97
MsgLogger.h
TMVA::GeneticPopulation::GiveHint
void GiveHint(std::vector< Double_t > &hint, Double_t fitness=0)
add an individual (a set of variables) to the population if there is a set of variables which is know...
Definition: GeneticPopulation.cxx:310
TRandom3
Random number generator class based on M.
Definition: TRandom3.h:27
TMVA::GeneticPopulation::fPopulationSizeLimit
Int_t fPopulationSizeLimit
Definition: GeneticPopulation.h:102
TRandom3::SetSeed
virtual void SetSeed(ULong_t seed=0)
Set the random generator sequence if seed is 0 (default value) a TUUID is generated and used to fill ...
Definition: TRandom3.cxx:206
TRandom3.h
TMVA::GeneticGenes
Cut optimisation interface class for genetic algorithm.
Definition: GeneticGenes.h:41
TMVA::GeneticGenes::GetFactors
std::vector< Double_t > & GetFactors()
Definition: GeneticGenes.h:49
TMVA::Endl
MsgLogger & Endl(MsgLogger &ml)
Definition: MsgLogger.h:158
unsigned int
Double_t
double Double_t
Definition: RtypesCore.h:59
TMVA::MsgLogger
ostringstream derivative to redirect and format output
Definition: MsgLogger.h:59
TMVA::GeneticPopulation::Sort
void Sort()
sort the genepool according to the fitness of the individuals
Definition: GeneticPopulation.cxx:321
TH1F
1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:575
TMVA::GeneticPopulation::~GeneticPopulation
virtual ~GeneticPopulation()
destructor
Definition: GeneticPopulation.cxx:78
TMVA::GeneticPopulation::GetGenes
GeneticGenes * GetGenes(Int_t index)
gives back the "Genes" of the population with the given index.
Definition: GeneticPopulation.cxx:194
TMVA::GeneticPopulation::Mutate
void Mutate(Double_t probability=20, Int_t startIndex=0, Bool_t near=kFALSE, Double_t spread=0.1, Bool_t mirror=kFALSE)
Mutates the individuals in the genePool.
Definition: GeneticPopulation.cxx:168
TH1.h
TMVA::GeneticPopulation::Print
void Print(Int_t untilIndex=-1)
make a little printout of the individuals up to index "untilIndex" this means, .
Definition: GeneticPopulation.cxx:203
TMVA::GeneticPopulation::MakeCopies
void MakeCopies(int number)
Produces offspring which is are copies of their parents.
Definition: GeneticPopulation.cxx:104
int
TMVA::GeneticPopulation
Population definition for genetic algorithm.
Definition: GeneticPopulation.h:48
g
#define g(i)
Definition: RSha256.hxx:105