Logo ROOT  
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"
52#include "TVector.h"
53
54namespace 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);
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
155 kkNN
157
159 kBox = 0,
163 kSinc3, // the sinc enumerators must be consecutive and in order!
172 kTrim
174
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
#define e(i)
Definition: RSha256.hxx:103
int Int_t
Definition: RtypesCore.h:41
unsigned int UInt_t
Definition: RtypesCore.h:42
bool Bool_t
Definition: RtypesCore.h:59
double Double_t
Definition: RtypesCore.h:55
float Float_t
Definition: RtypesCore.h:53
#define ClassDef(name, id)
Definition: Rtypes.h:326
int type
Definition: TGX11.cxx:120
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:48
Node for the BinarySearch or Decision Trees.
A simple Binary search tree including a volume search method.
Class that contains all the data information.
Definition: DataSetInfo.h:60
Virtual base Class for all MVA method.
Definition: MethodBase.h:111
This is a generalization of the above Likelihood methods to dimensions, where is the number of inpu...
Definition: MethodPDERS.h:59
void WriteWeightsToStream(TFile &rf) const
write training sample (TTree) to file
static MethodPDERS *& GetMethodPDERSThreadLocal()
Definition: MethodPDERS.h:214
void CreateBinarySearchTree(Types::ETreeType type)
create binary search trees for signal and background
BinarySearchTree * fBinaryTree
Definition: MethodPDERS.h:175
std::vector< Float_t > * fDelta
Definition: MethodPDERS.h:177
virtual ~MethodPDERS(void)
destructor
Bool_t fInitializedVolumeEle
Definition: MethodPDERS.h:195
MethodPDERS(const TString &jobName, const TString &methodTitle, DataSetInfo &theData, const TString &theOption)
standard constructor for the PDERS method
void GetSample(const Event &e, std::vector< const BinarySearchTreeNode * > &events, Volume *volume)
Double_t fMax_distance
Definition: MethodPDERS.h:200
Double_t fGaussSigma
Definition: MethodPDERS.h:184
Float_t GetError(Float_t countS, Float_t countB, Float_t sumW2S, Float_t sumW2B) const
statistical error estimate for RS estimator
BinarySearchTree * GetBinaryTree(void) const
Definition: MethodPDERS.h:114
static MethodPDERS * ThisPDERS(void)
static pointer to this object
Double_t KernelNormalization(Double_t pdf)
Calculating the normalization factor only once (might need a reset at some point.
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
std::vector< Float_t > fAverageRMS
Definition: MethodPDERS.h:179
void ReadWeightsFromXML(void *wghtnode)
TString fKernelString
Definition: MethodPDERS.h:147
void ProcessOptions()
process the options specified by the user
Float_t fInitialScale
Definition: MethodPDERS.h:193
void RRScalc(const Event &, std::vector< Float_t > *count)
void GetHelpMessage() const
get help message text
void UpdateThis()
update static this pointer
void Train(void)
this is a dummy training: the preparation work to do is the construction of the binary tree as a poin...
void MakeClassSpecific(std::ostream &, const TString &) const
write specific classifier response
Double_t CRScalc(const Event &)
void DeclareOptions()
define the options (their key words) that can be set in the option string.
const Ranking * CreateRanking()
Definition: MethodPDERS.h:128
Double_t fGaussSigmaNorm
Definition: MethodPDERS.h:185
std::vector< Float_t > * fShift
Definition: MethodPDERS.h:178
void CalcAverages()
compute also average RMS values required for adaptive Gaussian
enum TMVA::MethodPDERS::EVolumeRangeMode fVRangeMode
void RKernelEstimate(const Event &, std::vector< const BinarySearchTreeNode * > &, Volume &, std::vector< Float_t > *pdfSum)
normalization factors so we can work with radius 1 hyperspheres
void ReadWeightsFromStream(std::istream &istr)
read weight info from file
enum TMVA::MethodPDERS::EKernelEstimator fKernelEstimator
const std::vector< Float_t > & GetRegressionValues()
Double_t NormSinc(Double_t x)
NormSinc.
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.
void AddWeightsXMLTo(void *parent) const
write weights to xml file
void SetVolumeElement(void)
defines volume dimensions
void Init(void)
default initialisation routine called by all constructors
Double_t LanczosFilter(Int_t level, Double_t x)
Lanczos Filter.
Double_t CKernelEstimate(const Event &, std::vector< const BinarySearchTreeNode * > &, Volume &)
normalization factors so we can work with radius 1 hyperspheres
Float_t fMaxVIterations
Definition: MethodPDERS.h:192
Double_t ApplyKernelFunction(Double_t normalized_distance)
from the normalized euclidean distance calculate the distance for a certain kernel
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.
static Double_t IGetVolumeContentForRoot(Double_t)
Interface to RootFinder.
TString fVolumeRange
Definition: MethodPDERS.h:146
Double_t GetVolumeContentForRoot(Double_t)
count number of events in rescaled volume
Volume * fHelpVolume
Definition: MethodPDERS.h:110
Ranking for variables in method (implementation)
Definition: Ranking.h:48
EAnalysisType
Definition: Types.h:127
Volume for BinarySearchTree.
Definition: Volume.h:48
Basic string class.
Definition: TString.h:131
Double_t x[n]
Definition: legend1.C:17
create variable transformations