Logo ROOT   6.10/09
Reference Guide
MethodPDERS.h
Go to the documentation of this file.
1 // @(#)root/tmva $Id$
2 // Author: Andreas Hoecker, Yair Mahalalel, Joerg Stelzer, Helge Voss, Kai Voss
3 
4 /**********************************************************************************
5  * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
6  * Package: TMVA *
7  * Class : MethodPDERS *
8  * Web : http://tmva.sourceforge.net *
9  * *
10  * Description: *
11  * Multidimensional Likelihood using the "Probability density estimator *
12  * range search" (PDERS) method suggested in *
13  * T. Carli and B. Koblitz, NIM A 501, 576 (2003) *
14  * *
15  * The multidimensional PDFs for signal and background are modeled *
16  * by counting the events in the "vicinity" of a test point. The volume *
17  * that describes "vicinity" is user-defined through the option string. *
18  * A search method based on binary-trees is used to improve the selection *
19  * efficiency of the volume search. *
20  * *
21  * Authors (alphabetical): *
22  * Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
23  * Yair Mahalalel <Yair.Mahalalel@cern.ch> - CERN, Switzerland *
24  * Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *
25  * Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, Germany *
26  * Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
27  * *
28  * Copyright (c) 2005: *
29  * CERN, Switzerland *
30  * U. of Victoria, Canada *
31  * MPI-K Heidelberg, Germany *
32  * *
33  * Redistribution and use in source and binary forms, with or without *
34  * modification, are permitted according to the terms listed in LICENSE *
35  * (http://tmva.sourceforge.net/LICENSE) *
36  **********************************************************************************/
37 
38 #ifndef ROOT_TMVA_MethodPDERS
39 #define ROOT_TMVA_MethodPDERS
40 
41 //////////////////////////////////////////////////////////////////////////
42 // //
43 // MethodPDERS //
44 // //
45 // Multidimensional Likelihood using the "Probability density //
46 // estimator range search" (PDERS) method //
47 // //
48 //////////////////////////////////////////////////////////////////////////
49 
50 #include "TMVA/MethodBase.h"
51 #include "TMVA/BinarySearchTree.h"
52 #include "TVector.h"
53 
54 namespace TMVA {
55 
56  class Volume;
57  class Event;
58 
59  class MethodPDERS : public MethodBase {
60 
61  public:
62 
63  MethodPDERS( const TString& jobName,
64  const TString& methodTitle,
65  DataSetInfo& theData,
66  const TString& theOption);
67 
68  MethodPDERS( DataSetInfo& theData,
69  const TString& theWeightFile);
70 
71  virtual ~MethodPDERS( void );
72 
73  virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets );
74 
75 
76  // training method
77  void Train( void );
78 
79  // write weights to file
80  void WriteWeightsToStream( TFile& rf ) const;
81  void AddWeightsXMLTo( void* parent ) const;
82 
83  // read weights from file
84  void ReadWeightsFromStream( std::istream& istr );
85  void ReadWeightsFromStream( TFile& istr );
86  void ReadWeightsFromXML( void* wghtnode );
87 
88  // calculate the MVA value
89  Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0 );
90 
91  // calculate the MVA value
92  const std::vector<Float_t>& GetRegressionValues();
93  public:
94 
95  // for root finder
98 
99  // static pointer to this object
100  static MethodPDERS* ThisPDERS( void );
101 
102  protected:
103 
104  // make ROOT-independent C++ class for classifier response (classifier-specific implementation)
105  void MakeClassSpecific( std::ostream&, const TString& ) const;
106 
107  // get help message text
108  void GetHelpMessage() const;
109 
110  Volume* fHelpVolume; // auxiliary variable
111  Int_t fFcnCall; // number of external function calls (RootFinder)
112 
113  // accessors
114  BinarySearchTree* GetBinaryTree( void ) const { return fBinaryTree; }
115 
116  Double_t CKernelEstimate( const Event&, std::vector<const BinarySearchTreeNode*>&, Volume& );
117  void RKernelEstimate( const Event&, std::vector<const BinarySearchTreeNode*>&, Volume&, std::vector<Float_t> *pdfSum );
118 
119  Double_t ApplyKernelFunction( Double_t normalized_distance );
121  Double_t GetNormalizedDistance( const TMVA::Event &base_event,
122  const BinarySearchTreeNode &sample_event,
123  Double_t *dim_normalization);
125  Double_t LanczosFilter( Int_t level, Double_t x );
126 
127  // ranking of input variables
128  const Ranking* CreateRanking() { return 0; }
129 
130  private:
131 
132  // the option handling methods
133  void DeclareOptions();
134  void ProcessOptions();
135 
136  // calculate the averages of the input variables needed for adaptive training
137  void CalcAverages();
138 
139  // create binary search trees for signal and background
141 
142  // get sample of training events
143  void GetSample( const Event &e, std::vector<const BinarySearchTreeNode*>& events, Volume *volume);
144 
145  // option
146  TString fVolumeRange; // option volume range
147  TString fKernelString; // option kernel estimator
148 
156  } fVRangeMode;
157 
159  kBox = 0,
163  kSinc3, // the sinc enumerators must be consecutive and in order!
174 
175  BinarySearchTree* fBinaryTree; // binary tree
176 
177  std::vector<Float_t>* fDelta; // size of volume
178  std::vector<Float_t>* fShift; // volume center
179  std::vector<Float_t> fAverageRMS; // average RMS of signal and background
180 
181  Float_t fScaleS; // weight for signal events
182  Float_t fScaleB; // weight for background events
183  Float_t fDeltaFrac; // fraction of RMS
184  Double_t fGaussSigma; // size of Gauss in adaptive volume
185  Double_t fGaussSigmaNorm;// size of Gauss in adaptive volume (normalised to dimensions)
186 
187  Double_t fNRegOut; // number of output dimensions for regression
188 
189  // input for adaptive volume adjustment
190  Float_t fNEventsMin; // minimum number of events in adaptive volume
191  Float_t fNEventsMax; // maximum number of events in adaptive volume
192  Float_t fMaxVIterations;// maximum number of iterations to adapt volume size
193  Float_t fInitialScale; // initial scale for adaptive volume
194 
195  Bool_t fInitializedVolumeEle; // is volume element initialized ?
196 
197  Int_t fkNNMin; // min number of events in kNN tree
198  Int_t fkNNMax; // max number of events in kNN tree
199 
200  Double_t fMax_distance; // maximum distance
201  Bool_t fPrinted; // print
202  Bool_t fNormTree; // binary-search tree is normalised
203 
204  void SetVolumeElement ( void );
205 
206  Double_t CRScalc ( const Event& );
207  void RRScalc ( const Event&, std::vector<Float_t>* count );
208 
209  Float_t GetError ( Float_t countS, Float_t countB,
210  Float_t sumW2S, Float_t sumW2B ) const;
211 
212  // This is a workaround for OSx where static thread_local data members are
213  // not supported. The C++ solution would indeed be the following:
214  static MethodPDERS*& GetMethodPDERSThreadLocal() {TTHREAD_TLS(MethodPDERS*) fgThisPDERS(nullptr); return fgThisPDERS;};
215  void UpdateThis();
216 
217  void Init( void );
218 
219  ClassDef(MethodPDERS,0); // Multi-dimensional probability density estimator range search (PDERS) method
220  };
221 
222 } // namespace TMVA
223 
224 #endif // MethodPDERS_H
void WriteWeightsToStream(TFile &rf) const
write training sample (TTree) to file
void UpdateThis()
update static this pointer
virtual ~MethodPDERS(void)
destructor
Double_t GetNormalizedDistance(const TMVA::Event &base_event, const BinarySearchTreeNode &sample_event, Double_t *dim_normalization)
We use Euclidian metric here. Might not be best or most efficient.
std::vector< Float_t > * fShift
Definition: MethodPDERS.h:178
Float_t fMaxVIterations
Definition: MethodPDERS.h:192
float Float_t
Definition: RtypesCore.h:53
void GetHelpMessage() const
get help message text
BinarySearchTree * fBinaryTree
Definition: MethodPDERS.h:175
Double_t NormSinc(Double_t x)
NormSinc.
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format...
Definition: TFile.h:46
EAnalysisType
Definition: Types.h:125
void CreateBinarySearchTree(Types::ETreeType type)
create binary search trees for signal and background
Virtual base Class for all MVA method.
Definition: MethodBase.h:106
Basic string class.
Definition: TString.h:129
void AddWeightsXMLTo(void *parent) const
write weights to xml file
Ranking for variables in method (implementation)
Definition: Ranking.h:48
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
void RKernelEstimate(const Event &, std::vector< const BinarySearchTreeNode *> &, Volume &, std::vector< Float_t > *pdfSum)
normalization factors so we can work with radius 1 hyperspheres
Float_t fInitialScale
Definition: MethodPDERS.h:193
Double_t GetMvaValue(Double_t *err=0, Double_t *errUpper=0)
init the size of a volume element using a defined fraction of the volume containing the entire events...
Node for the BinarySearch or Decision Trees.
Double_t fMax_distance
Definition: MethodPDERS.h:200
Volume for BinarySearchTree.
Definition: Volume.h:48
void GetSample(const Event &e, std::vector< const BinarySearchTreeNode *> &events, Volume *volume)
void Init(void)
default initialisation routine called by all constructors
static Double_t IGetVolumeContentForRoot(Double_t)
Interface to RootFinder.
Double_t x[n]
Definition: legend1.C:17
#define ClassDef(name, id)
Definition: Rtypes.h:297
void ReadWeightsFromStream(std::istream &istr)
read weight info from file
TString fVolumeRange
Definition: MethodPDERS.h:146
Float_t GetError(Float_t countS, Float_t countB, Float_t sumW2S, Float_t sumW2B) const
statistical error estimate for RS estimator
Class that contains all the data information.
Definition: DataSetInfo.h:60
void CalcAverages()
compute also average RMS values required for adaptive Gaussian
Double_t CRScalc(const Event &)
TString fKernelString
Definition: MethodPDERS.h:147
void DeclareOptions()
define the options (their key words) that can be set in the option string.
Double_t fGaussSigma
Definition: MethodPDERS.h:184
void SetVolumeElement(void)
defines volume dimensions
Bool_t fInitializedVolumeEle
Definition: MethodPDERS.h:195
BinarySearchTree * GetBinaryTree(void) const
Definition: MethodPDERS.h:114
unsigned int UInt_t
Definition: RtypesCore.h:42
void ReadWeightsFromXML(void *wghtnode)
static MethodPDERS * ThisPDERS(void)
static pointer to this object
This is a generalization of the above Likelihood methods to dimensions, where is the number of inpu...
Definition: MethodPDERS.h:59
void Train(void)
this is a dummy training: the preparation work to do is the construction of the binary tree as a poin...
Volume * fHelpVolume
Definition: MethodPDERS.h:110
std::vector< Float_t > * fDelta
Definition: MethodPDERS.h:177
double Double_t
Definition: RtypesCore.h:55
enum TMVA::MethodPDERS::EKernelEstimator fKernelEstimator
int type
Definition: TGX11.cxx:120
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
virtual Bool_t HasAnalysisType(Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
PDERS can handle classification with 2 classes and regression with one or more regression-targets.
Double_t CKernelEstimate(const Event &, std::vector< const BinarySearchTreeNode *> &, Volume &)
normalization factors so we can work with radius 1 hyperspheres
std::vector< Float_t > fAverageRMS
Definition: MethodPDERS.h:179
const std::vector< Float_t > & GetRegressionValues()
Abstract ClassifierFactory template that handles arbitrary types.
enum TMVA::MethodPDERS::EVolumeRangeMode fVRangeMode
void ProcessOptions()
process the options specified by the user
Double_t GetVolumeContentForRoot(Double_t)
count number of events in rescaled volume
const Ranking * CreateRanking()
Definition: MethodPDERS.h:128
MethodPDERS(const TString &jobName, const TString &methodTitle, DataSetInfo &theData, const TString &theOption)
standard constructor for the PDERS method
static MethodPDERS *& GetMethodPDERSThreadLocal()
Definition: MethodPDERS.h:214
Double_t ApplyKernelFunction(Double_t normalized_distance)
from the normalized euclidean distance calculate the distance for a certain kernel ...
Double_t fGaussSigmaNorm
Definition: MethodPDERS.h:185
A simple Binary search tree including a volume search method.
Double_t LanczosFilter(Int_t level, Double_t x)
Lanczos Filter.
void RRScalc(const Event &, std::vector< Float_t > *count)
Double_t KernelNormalization(Double_t pdf)
Calculating the normalization factor only once (might need a reset at some point. ...
void MakeClassSpecific(std::ostream &, const TString &) const
write specific classifier response