Logo ROOT   master
Reference Guide
MethodPDEFoam.h
Go to the documentation of this file.
1 // @(#)root/tmva $Id$
2 // Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt
3 
4 /**********************************************************************************
5  * Project: TMVA - a Root-integrated toolkit for multivariate Data analysis *
6  * Package: TMVA *
7  * Class : MethodPDEFoam *
8  * Web : http://tmva.sourceforge.net *
9  * *
10  * Description: *
11  * The PDEFoam method is an extension of the PDERS method, which divides *
12  * the multi-dimensional phase space in a finite number of hyper-rectangles *
13  * (cells) of constant event density. This "foam" of cells is filled with *
14  * averaged probability-density information sampled from a training event *
15  * sample. *
16  * *
17  * Authors (alphabetical): *
18  * Tancredi Carli - CERN, Switzerland *
19  * Dominik Dannheim - CERN, Switzerland *
20  * Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *
21  * Alexander Voigt - TU Dresden, Germany *
22  * *
23  * Original author of the TFoam implementation: *
24  * S. Jadach - Institute of Nuclear Physics, Cracow, Poland *
25  * *
26  * Copyright (c) 2008, 2010: *
27  * CERN, Switzerland *
28  * MPI-K Heidelberg, Germany *
29  * *
30  * Redistribution and use in source and binary forms, with or without *
31  * modification, are permitted according to the terms listed in LICENSE *
32  * (http://tmva.sourceforge.net/LICENSE) *
33  **********************************************************************************/
34 
35 #ifndef ROOT_TMVA_MethodPDEFoam
36 #define ROOT_TMVA_MethodPDEFoam
37 
38 //////////////////////////////////////////////////////////////////////////////
39 // //
40 // MethodPDEFoam //
41 // //
42 //////////////////////////////////////////////////////////////////////////////
43 
44 #include "TMVA/MethodBase.h"
45 
46 #include "TMVA/PDEFoam.h"
47 
49 #include "TMVA/PDEFoamEvent.h"
51 #include "TMVA/PDEFoamTarget.h"
53 
59 
60 #include "TMVA/PDEFoamKernelBase.h"
62 #include "TMVA/PDEFoamKernelLinN.h"
64 
65 namespace TMVA {
66 
67  class MethodPDEFoam : public MethodBase {
68 
69  public:
70 
71  // kernel types
72  typedef enum EKernel { kNone=0, kGaus=1, kLinN=2 } EKernel;
73 
74  MethodPDEFoam( const TString& jobName,
75  const TString& methodTitle,
76  DataSetInfo& dsi,
77  const TString& theOption = "PDEFoam");
78 
80  const TString& theWeightFile);
81 
82  virtual ~MethodPDEFoam( void );
83 
84  virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets );
85 
86  // training methods
87  void Train( void );
88  void TrainMonoTargetRegression( void ); // Regression output: one value
89  void TrainMultiTargetRegression( void ); // Regression output: any number of values
90  void TrainSeparatedClassification( void ); // Classification: one foam for Sig, one for Bg
91  void TrainUnifiedClassification( void ); // Classification: one foam for Signal and Bg
92  void TrainMultiClassification(); // Classification: one foam for every class
93 
95 
96  // write weights to stream
97  void AddWeightsXMLTo( void* parent ) const;
98 
99  // read weights from stream
100  void ReadWeightsFromStream( std::istream & i );
101  void ReadWeightsFromXML ( void* wghtnode );
102 
103  // write/read pure foams to/from file
104  void WriteFoamsToFile() const;
105  void ReadFoamsFromFile();
107 
108  // calculate the MVA value
109  Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );
110 
111  // calculate multiclass MVA values
112  const std::vector<Float_t>& GetMulticlassValues();
113 
114  // regression procedure
115  virtual const std::vector<Float_t>& GetRegressionValues();
116 
117  // reset the method
118  virtual void Reset();
119 
120  // ranking of input variables
121  const Ranking* CreateRanking();
122 
123  // get number of cuts in every dimension, starting at cell
124  void GetNCuts(PDEFoamCell *cell, std::vector<UInt_t> &nCuts);
125 
126  // helper functions to convert enum types to UInt_t and back
127  EKernel GetKernel( void ) { return fKernel; }
128  UInt_t KernelToUInt(EKernel ker) const { return UInt_t(ker); }
130  UInt_t TargetSelectionToUInt(ETargetSelection ts) const { return UInt_t(ts); }
131  ETargetSelection UIntToTargetSelection(UInt_t its);
132 
133  protected:
134 
135  // make ROOT-independent C++ class for classifier response (classifier-specific implementation)
136  void MakeClassSpecific( std::ostream&, const TString& ) const;
137 
138  // get help message text
139  void GetHelpMessage() const;
140 
141  // calculate the error on the Mva value
143 
144  // calculate Xmin and Xmax for Foam
145  void CalcXminXmax();
146 
147  // Set Xmin, Xmax in foam with index 'foam_index'
148  void SetXminXmax(TMVA::PDEFoam*);
149 
150  // create foam and set foam options
151  PDEFoam* InitFoam(TString, EFoamType, UInt_t cls=0);
152 
153  // create pdefoam kernel
155 
156  // delete all trained foams
157  void DeleteFoams();
158 
159  // fill variable names into foam
160  void FillVariableNamesToFoam() const;
161 
162  private:
163 
164  // the option handling methods
165  void DeclareOptions();
167  void ProcessOptions();
168 
169  // nice output
170  void PrintCoefficients( void );
171 
172  // Square function (fastest implementation)
173  template<typename T> T Sqr(T x) const { return x*x; }
174 
175  // options to be used
176  Bool_t fSigBgSeparated; // Separate Sig and Bg, or not
177  Float_t fFrac; // Fraction used for calc of Xmin, Xmax
178  Float_t fDiscrErrCut; // cut on discriminant error
179  Float_t fVolFrac; // volume fraction (used for density calculation during buildup)
180  Int_t fnCells; // Number of Cells (1000)
181  Int_t fnActiveCells; // Number of active cells
182  Int_t fnSampl; // Number of MC events per cell in build-up (1000)
183  Int_t fnBin; // Number of bins in build-up (100)
184  Int_t fEvPerBin; // Maximum events (equiv.) per bin in build-up (1000)
185 
186  Bool_t fCompress; // compress foam output file
187  Bool_t fMultiTargetRegression; // do regression on multiple targets
188  UInt_t fNmin; // minimal number of events in cell necessary to split cell"
189  Bool_t fCutNmin; // Keep for bw compatibility: Grabbing cell with maximal RMS to split next (TFoam default)
190  UInt_t fMaxDepth; // maximum depth of cell tree
191 
192  TString fKernelStr; // Kernel for GetMvaValue() (option string)
193  EKernel fKernel; // Kernel for GetMvaValue()
194  PDEFoamKernelBase *fKernelEstimator;// Kernel estimator
195  TString fTargetSelectionStr; // method of selecting the target (only mulit target regr.)
196  ETargetSelection fTargetSelection; // method of selecting the target (only mulit target regr.)
197  Bool_t fFillFoamWithOrigWeights; // fill the foam with boost weights
198  Bool_t fUseYesNoCell; // return -1 or 1 for bg or signal like event
199  TString fDTLogic; // use DT algorithm to split cells
200  EDTSeparation fDTSeparation; // enum which specifies the separation to use for the DT logic
201  Bool_t fPeekMax; // BACKWARDS COMPATIBILITY: peek up cell with max. driver integral for split
202 
203  std::vector<Float_t> fXmin, fXmax; // range for histograms and foams
204 
205  std::vector<PDEFoam*> fFoam; // grown PDEFoams
206 
207  // default initialisation called by all constructors
208  void Init( void );
209 
210  ClassDef(MethodPDEFoam,0); // Multi-dimensional probability density estimator using TFoam (PDE-Foam)
211  };
212 
213 } // namespace TMVA
214 
215 #endif // MethodPDEFoam_H
void Train(void)
Train PDE-Foam depending on the set options.
std::vector< Float_t > fXmax
The PDEFoam method is an extension of the PDERS method, which divides the multi-dimensional phase spa...
Definition: MethodPDEFoam.h:67
virtual void Reset()
reset MethodPDEFoam:
Bool_t fFillFoamWithOrigWeights
This class is the abstract kernel interface for PDEFoam.
UInt_t KernelToUInt(EKernel ker) const
void GetNCuts(PDEFoamCell *cell, std::vector< UInt_t > &nCuts)
Fill in &#39;nCuts&#39; the number of cuts made in every foam dimension, starting at the root cell &#39;cell&#39;...
float Float_t
Definition: RtypesCore.h:53
PDEFoam * InitFoam(TString, EFoamType, UInt_t cls=0)
Create a new PDEFoam, set the PDEFoam options (nCells, nBin, Xmin, Xmax, etc.) and initialize the PDE...
double T(double x)
Definition: ChebyshevPol.h:34
void PrintCoefficients(void)
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format...
Definition: TFile.h:48
EAnalysisType
Definition: Types.h:127
Virtual base Class for all MVA method.
Definition: MethodBase.h:111
Basic string class.
Definition: TString.h:131
Ranking for variables in method (implementation)
Definition: Ranking.h:48
void TrainUnifiedClassification(void)
Create only one unified foam (fFoam[0]) whose cells contain the average discriminator (N_sig)/(N_sig ...
bool Bool_t
Definition: RtypesCore.h:59
void FillVariableNamesToFoam() const
store the variable names in all foams
void GetHelpMessage() const
provide help message
Double_t x[n]
Definition: legend1.C:17
#define ClassDef(name, id)
Definition: Rtypes.h:326
void ReadWeightsFromStream(std::istream &i)
read options and internal parameters
virtual ~MethodPDEFoam(void)
destructor
void DeclareOptions()
Declare MethodPDEFoam options.
Class that contains all the data information.
Definition: DataSetInfo.h:60
std::vector< Float_t > fXmin
void SetXminXmax(TMVA::PDEFoam *)
Set Xmin, Xmax for every dimension in the given pdefoam object.
PDEFoam * ReadClonedFoamFromFile(TFile *, const TString &)
Reads a foam with name &#39;foamname&#39; from file, and returns a clone of the foam.
Implementation of PDEFoam.
Definition: PDEFoam.h:77
void AddWeightsXMLTo(void *parent) const
create XML output of PDEFoam method variables
Double_t CalculateMVAError()
Calculate the error on the Mva value.
void Init(void)
default initialization called by all constructors
void CalcXminXmax()
Determine foam range [fXmin, fXmax] for all dimensions, such that a fraction of &#39;fFrac&#39; events lie ou...
virtual Bool_t HasAnalysisType(Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
PDEFoam can handle classification with multiple classes and regression with one or more regression-ta...
MethodPDEFoam(const TString &jobName, const TString &methodTitle, DataSetInfo &dsi, const TString &theOption="PDEFoam")
init PDEFoam objects
PDEFoamKernelBase * fKernelEstimator
EKernel UIntToKernel(UInt_t iker)
convert UInt_t to EKernel (used for reading weight files)
unsigned int UInt_t
Definition: RtypesCore.h:42
ETargetSelection UIntToTargetSelection(UInt_t its)
convert UInt_t to ETargetSelection (used for reading weight files)
Double_t GetMvaValue(Double_t *err=0, Double_t *errUpper=0)
Return Mva-Value.
void TrainMultiTargetRegression(void)
Training one (multi target regression) foam, whose cells contain the average event density...
UInt_t TargetSelectionToUInt(ETargetSelection ts) const
void MakeClassSpecific(std::ostream &, const TString &) const
write PDEFoam-specific classifier response NOT IMPLEMENTED YET!
void TrainSeparatedClassification(void)
Creation of 2 separated foams: one for signal events, one for background events.
void WriteFoamsToFile() const
Write PDEFoams to file.
void ReadWeightsFromXML(void *wghtnode)
read PDEFoam variables from xml weight file
EKernel GetKernel(void)
double Double_t
Definition: RtypesCore.h:55
void TrainMultiClassification()
Create one unified foam (see TrainUnifiedClassification()) for each class, where the cells of foam i ...
int type
Definition: TGX11.cxx:120
std::vector< PDEFoam * > fFoam
PDEFoamKernelBase * CreatePDEFoamKernel()
create a pdefoam kernel estimator, depending on the current value of fKernel
void TrainMonoTargetRegression(void)
Training one (mono target regression) foam, whose cells contain the average 0th target.
const std::vector< Float_t > & GetMulticlassValues()
Get the multiclass MVA response for the PDEFoam classifier.
const Ranking * CreateRanking()
Compute ranking of input variables from the number of cuts made in each PDEFoam dimension.
create variable transformations
void DeleteFoams()
Deletes all trained foams.
ETargetSelection fTargetSelection
EDTSeparation fDTSeparation
virtual const std::vector< Float_t > & GetRegressionValues()
Return regression values for both multi- and mono-target regression.
void ProcessOptions()
process user options
virtual void ReadWeightsFromStream(std::istream &)=0
void DeclareCompatibilityOptions()
options that are used ONLY for the READER to ensure backward compatibility
void ReadFoamsFromFile()
read foams from file