class TMVA::MethodPDERS: public TMVA::MethodBase
/* This is a generalization of the above Likelihood methods to Nvar dimensions, where Nvar is the number of input variables used in the MVA. If the multi-dimensional probability density functions (PDFs) for signal and background were known, this method contains the entire physical information, and is therefore optimal. Usually, kernel estimation methods are used to approximate the PDFs using the events from the training sample.
A very simple probability density estimator (PDE) has been suggested in hep-ex/0211019. The PDE for a given test event is obtained from counting the (normalized) number of signal and background (training) events that occur in the "vicinity" of the test event. The volume that describes "vicinity" is user-defined. A search method based on binary-trees is used to effectively reduce the selection time for the range search. Three different volume definitions are optional:
- MinMax: the volume is defined in each dimension with respect to the full variable range found in the training sample.
- RMS: the volume is defined in each dimensions with respect to the RMS estimated from the training sample.
- Adaptive: a volume element is defined in each dimensions with respect to the RMS estimated from the training sample. The overall scale of the volume element is then determined for each event so that the total number of events confined in the volume be within a user-defined range.
Function Members (Methods)
public:
protected:
private:
| void | CalcAverages() |
| void | CreateBinarySearchTree(TMVA::Types::ETreeType type) |
| Double_t | CRScalc(const TMVA::Event&) |
| virtual void | DeclareOptions() |
| Float_t | GetError(Float_t countS, Float_t countB, Float_t sumW2S, Float_t sumW2B) const |
| void | GetSample(const TMVA::Event& e, vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >& events, TMVA::Volume* volume) |
| virtual void | Init() |
| virtual void | ProcessOptions() |
| void | RRScalc(const TMVA::Event&, vector<Float_t>* count) |
| void | SetVolumeElement() |
| void | UpdateThis() |
Data Members
private:
| enum EVolumeRangeMode { | kUnsupported | |
| kMinMax | ||
| kRMS | ||
| kAdaptive | ||
| kUnscaled | ||
| kkNN | ||
| }; | ||
| enum EKernelEstimator { | kBox | |
| kSphere | ||
| kTeepee | ||
| kGauss | ||
| kSinc3 | ||
| kSinc5 | ||
| kSinc7 | ||
| kSinc9 | ||
| kSinc11 | ||
| kLanczos2 | ||
| kLanczos3 | ||
| kLanczos5 | ||
| kLanczos8 | ||
| kTrim | ||
| }; | ||
| enum TMVA::MethodBase::EWeightFileType { | kROOT | |
| kTEXT | ||
| }; | ||
| enum TMVA::MethodBase::ECutOrientation { | kNegative | |
| kPositive | ||
| }; | ||
| enum TObject::EStatusBits { | kCanDelete | |
| kMustCleanup | ||
| kObjInCanvas | ||
| kIsReferenced | ||
| kHasUUID | ||
| kCannotPick | ||
| kNoContextMenu | ||
| kInvalidObject | ||
| }; | ||
| enum TObject::[unnamed] { | kIsOnHeap | |
| kNotDeleted | ||
| kZombie | ||
| kBitMask | ||
| kSingleKey | ||
| kOverwrite | ||
| kWriteDelete | ||
| }; |
public:
| Bool_t | TMVA::MethodBase::fSetupCompleted | is method setup |
protected:
| TMVA::Types::EAnalysisType | TMVA::MethodBase::fAnalysisType | method-mode : true --> regression, false --> classification |
| UInt_t | TMVA::MethodBase::fBackgroundClass | index of the Background-class |
| Int_t | fFcnCall | number of external function calls (RootFinder) |
| TMVA::Volume* | fHelpVolume | auxiliary variable |
| vector<TString>* | TMVA::MethodBase::fInputVars | vector of input variables used in MVA |
| Int_t | TMVA::MethodBase::fNbins | number of bins in representative histograms |
| Int_t | TMVA::MethodBase::fNbinsH | number of bins in evaluation histograms |
| TMVA::Ranking* | TMVA::MethodBase::fRanking | pointer to ranking object (created by derived classifiers) |
| vector<Float_t>* | TMVA::MethodBase::fRegressionReturnVal | holds the return-value for the regression |
| UInt_t | TMVA::MethodBase::fSignalClass | index of the Signal-class |
| Bool_t | TMVA::MethodBase::fTxtWeightsOnly | if TRUE, write weights only to text files |
private:
| vector<Float_t> | fAverageRMS | average RMS of signal and background |
| TMVA::BinarySearchTree* | fBinaryTree | binary tree |
| vector<Float_t>* | fDelta | size of volume |
| Float_t | fDeltaFrac | fraction of RMS |
| Double_t | fGaussSigma | size of Gauss in adaptive volume |
| Double_t | fGaussSigmaNorm | size of Gauss in adaptive volume (normalised to dimensions) |
| Float_t | fInitialScale | initial scale for adaptive volume |
| Bool_t | fInitializedVolumeEle | is volume element initialized ? |
| TMVA::MethodPDERS::EKernelEstimator | fKernelEstimator | |
| TString | fKernelString | option kernel estimator |
| Float_t | fMaxVIterations | maximum number of iterations to adapt volume size |
| Double_t | fMax_distance | maximum distance |
| Float_t | fNEventsMax | maximum number of events in adaptive volume |
| Float_t | fNEventsMin | minimum number of events in adaptive volume |
| Double_t | fNRegOut | number of output dimensions for regression |
| Bool_t | fNormTree | binary-search tree is normalised |
| Bool_t | fPrinted | |
| Float_t | fScaleB | weight for background events |
| Float_t | fScaleS | weight for signal events |
| vector<Float_t>* | fShift | volume center |
| TMVA::MethodPDERS::EVolumeRangeMode | fVRangeMode | |
| TString | fVolumeRange | option volume range |
| static TMVA::MethodPDERS* | fgThisPDERS | this pointer (required by root finder) |
| Int_t | fkNNMax | max number of events in kNN tree |
| Int_t | fkNNMin | min number of events in kNN tree |
Class Charts
Function documentation
MethodPDERS(const TString& jobName, const TString& methodTitle, TMVA::DataSetInfo& theData, const TString& theOption, TDirectory* theTargetDir = 0)
standard constructor for the PDERS method
MethodPDERS(TMVA::DataSetInfo& theData, const TString& theWeightFile, TDirectory* theTargetDir = NULL)
construct MethodPDERS through from file
Bool_t HasAnalysisType(TMVA::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 DeclareOptions()
define the options (their key words) that can be set in the option string
know options:
VolumeRangeMode <string> Method to determine volume range
available values are: MinMax
Unscaled
RMS
kNN
Adaptive <default>
KernelEstimator <string> Kernel estimation function
available values are: Box <default>
Sphere
Teepee
Gauss
Sinc3
Sinc5
Sinc7
Sinc9
Sinc11
Lanczos2
Lanczos3
Lanczos5
Lanczos8
Trim
DeltaFrac <float> Ratio of #EventsMin/#EventsMax for MinMax and RMS volume range
NEventsMin <int> Minimum number of events for adaptive volume range
NEventsMax <int> Maximum number of events for adaptive volume range
MaxVIterations <int> Maximum number of iterations for adaptive volume range
InitialScale <float> Initial scale for adaptive volume range
GaussSigma <float> Width with respect to the volume size of Gaussian kernel estimator
void Train( void )
this is a dummy training: the preparation work to do is the construction of the binary tree as a pointer chain. It is easier to directly save the trainingTree in the weight file, and to rebuild the binary tree in the test phase from scratch
Double_t GetMvaValue(Double_t* err = 0)
init the size of a volume element using a defined fraction of the volume containing the entire events
const std::vector< Float_t >& GetRegressionValues()
void CreateBinarySearchTree(TMVA::Types::ETreeType type)
create binary search trees for signal and background
void GetSample(const TMVA::Event& e, vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >& events, TMVA::Volume* volume)
Double_t CKernelEstimate(const TMVA::Event& , vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >& , TMVA::Volume& )
normalization factors so we can work with radius 1 hyperspheres
void RKernelEstimate(const TMVA::Event& , vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >& , TMVA::Volume& , vector<Float_t>* pdfSum)
normalization factors so we can work with radius 1 hyperspheres
Double_t ApplyKernelFunction(Double_t normalized_distance)
from the normalized euclidean distance calculate the distance for a certain kernel
Double_t KernelNormalization(Double_t pdf)
Calculating the normalization factor only once (might need a reset at some point. Can the method be restarted with different params?)
Double_t GetNormalizedDistance(const TMVA::Event& base_event, const TMVA::BinarySearchTreeNode& sample_event, Double_t* dim_normalization)
We use Euclidian metric here. Might not be best or most efficient.
Float_t GetError(Float_t countS, Float_t countB, Float_t sumW2S, Float_t sumW2B) const
statistical error estimate for RS estimator
void ReadWeightsFromXML(void* wghtnode)
void GetHelpMessage() const
get help message text
typical length of text line:
"|--------------------------------------------------------------|"