library: libTMVA
#include "MethodLikelihood.h"

TMVA::MethodLikelihood


class description - header file - source file
viewCVS header - viewCVS source

class TMVA::MethodLikelihood: public TMVA::MethodBase

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
virtual~MethodLikelihood()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual const TMVA::Ranking*CreateRanking()
TMVA::DataSet&TMVA::MethodBase::Data() const
virtual voidTObject::Delete(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Double_tTMVA::MethodBase::GetEffForRoot(Double_t)
virtual Double_tTMVA::MethodBase::GetEfficiency(TString, TTree*)
Double_tTMVA::MethodBase::GetEventVal(Int_t ivar) const
Double_tTMVA::MethodBase::GetEventValNormalized(Int_t ivar) const
Double_tTMVA::MethodBase::GetEventWeight() const
virtual const char*TObject::GetIconName() const
const TString&TMVA::MethodBase::GetInputExp(int i) const
const TString&TMVA::MethodBase::GetInputVar(int i) const
virtual const TString&TMVA::MethodBase::GetJobName() const
virtual const TString&TMVA::MethodBase::GetMethodName() const
virtual const TString&TMVA::MethodBase::GetMethodTitle() const
virtual const TMVA::Types::EMVATMVA::MethodBase::GetMethodType() const
virtual Double_tTMVA::MethodBase::GetmuTransform(TTree*)
virtual Double_tGetMvaValue()
virtual const char*TMVA::MethodBase::GetName() const
Int_tTMVA::MethodBase::GetNvar() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Double_tTMVA::MethodBase::GetOptimalSignificance(Double_t SignalEvents, Double_t BackgroundEvents, Double_t& optimal_significance_value) const
virtual Option_t*TObject::GetOption() const
TStringTMVA::MethodBase::GetOptions() const
virtual TMVA::Types::EPreprocessingMethodTMVA::MethodBase::GetPreprocessingMethod() const
virtual Double_tTMVA::MethodBase::GetSeparation()
virtual Double_tTMVA::MethodBase::GetSignificance()
TTree*TMVA::MethodBase::GetTestTree() const
static TMVA::MethodBase*TMVA::MethodBase::GetThisBase()
virtual const char*TObject::GetTitle() const
virtual Double_tTMVA::MethodBase::GetTrainingEfficiency(TString)
TTree*TMVA::MethodBase::GetTrainingTree() const
virtual UInt_tTObject::GetUniqueID() const
virtual TStringTMVA::MethodBase::GetWeightFileDir() const
virtual TStringTMVA::MethodBase::GetWeightFileExtension() const
TStringTMVA::MethodBase::GetWeightFileName() const
TMVA::MethodBase::EWeightFileTypeTMVA::MethodBase::GetWeightFileType() const
Double_tTMVA::MethodBase::GetXmax(Int_t ivar, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
Double_tTMVA::MethodBase::GetXmax(const TString& var, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
Double_tTMVA::MethodBase::GetXmin(Int_t ivar, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
Double_tTMVA::MethodBase::GetXmin(const TString& var, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
Bool_tTMVA::MethodBase::HasTrainingTree() const
static Double_tTMVA::MethodBase::IGetEffForRoot(Double_t)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
virtual Bool_tTMVA::MethodBase::IsOK() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTMVA::MethodBase::IsSignalLike()
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
TMVA::MethodLikelihoodMethodLikelihood(TMVA::DataSet& theData, TString theWeightFile, TDirectory* theTargetDir = NULL)
TMVA::MethodLikelihoodMethodLikelihood(TString jobName, TString methodTitle, TMVA::DataSet& theData, TString theOption = , TDirectory* theTargetDir = 0)
Double_tTMVA::MethodBase::Norm(Int_t ivar, Double_t x) const
Double_tTMVA::MethodBase::Norm(TString var, Double_t x) const
virtual Bool_tTObject::Notify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TMVA::IMethod&TMVA::IMethod::operator=(const TMVA::IMethod&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTMVA::MethodBase::PrepareEvaluationTree(TTree* theTestTree)
virtual voidTObject::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTMVA::MethodBase::ReadStateFromFile()
virtual voidTMVA::MethodBase::ReadStateFromStream(istream& i)
virtual Bool_tReadTestEvent(UInt_t ievt, TMVA::Types::ESBType type = Types::kSignal)
Bool_tTMVA::MethodBase::ReadTrainingEvent(UInt_t ievt, TMVA::Types::ESBType type = Types::kMaxSBType)
virtual voidReadWeightsFromStream(istream& istr)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
virtual voidTMVA::MethodBase::SetJobName(TString jobName)
voidTMVA::MethodBase::SetMethodName(TString methodName)
voidTMVA::MethodBase::SetMethodTitle(TString methodTitle)
voidTMVA::MethodBase::SetMethodType(TMVA::Types::EMVA methodType)
voidTMVA::MethodBase::SetNvar(Int_t n)
static voidTObject::SetObjectStat(Bool_t stat)
voidTMVA::MethodBase::SetPreprocessingMethod(TMVA::Types::EPreprocessingMethod m)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidTMVA::MethodBase::SetVerbose(Bool_t v = kTRUE)
virtual voidTMVA::MethodBase::SetWeightFileDir(TString fileDir)
virtual voidTMVA::MethodBase::SetWeightFileExtension(TString fileExtension)
voidTMVA::MethodBase::SetWeightFileName(TString)
voidTMVA::MethodBase::SetWeightFileType(TMVA::MethodBase::EWeightFileType w)
voidTMVA::MethodBase::SetXmax(Int_t ivar, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
voidTMVA::MethodBase::SetXmax(const TString& var, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
voidTMVA::MethodBase::SetXmin(Int_t ivar, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
voidTMVA::MethodBase::SetXmin(const TString& var, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTMVA::MethodBase::Test(TTree* theTestTree = 0)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTMVA::MethodBase::TestInit(TTree* theTestTree = 0)
virtual voidTrain()
voidTMVA::MethodBase::TrainMethod()
virtual voidTObject::UseCurrentStyle()
Bool_tTMVA::MethodBase::Verbose() const
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const
virtual voidTMVA::MethodBase::WriteEvaluationHistosToFile(TDirectory* targetDir)
virtual voidWriteMonitoringHistosToFile() const
voidTMVA::MethodBase::WriteStateToFile() const
virtual voidTMVA::MethodBase::WriteStateToStream(ostream& o) const
virtual voidWriteWeightsToStream(ostream& o) const
protected:
TDirectory*TMVA::MethodBase::BaseDir() const
Bool_tTMVA::MethodBase::CheckSanity(TTree* theTree = 0)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTMVA::MethodBase::EnableLooseOptions(Bool_t b = kTRUE)
TMVA::MethodBase::ECutOrientationTMVA::MethodBase::GetCutOrientation() const
TMVA::Types::ESBTypeTMVA::MethodBase::GetPreprocessingType() const
Double_tTMVA::MethodBase::GetSignalReferenceCut() const
const TString&TMVA::MethodBase::GetTestvarName() const
const TString&TMVA::MethodBase::GetTestvarPrefix() const
const TList&TMVA::MethodBase::ListOfOptions() const
TDirectory*TMVA::MethodBase::LocalTDir() const
voidTObject::MakeZombie()
voidTMVA::MethodBase::ParseOptions(Bool_t verbose = kTRUE)
voidTMVA::MethodBase::PrintOptions() const
voidTMVA::MethodBase::ReadOptionsFromStream(istream& istr)
voidTMVA::MethodBase::ResetThisBase()
voidTMVA::MethodBase::SetPreprocessingType(TMVA::Types::ESBType t)
voidTMVA::MethodBase::SetSignalReferenceCut(Double_t cut)
voidTMVA::MethodBase::SetTestvarName()
voidTMVA::MethodBase::SetTestvarName(TString v)
voidTMVA::MethodBase::SetTestvarPrefix(TString prefix)
voidTMVA::MethodBase::Statistics(TMVA::Types::ETreeType treeType, const TString& theVarName, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Bool_t norm = kFALSE)
voidTMVA::MethodBase::WriteOptionsToStream(ostream& o) const
private:
virtual voidDeclareOptions()
voidInitLik()
virtual voidProcessOptions()

Data Members

public:
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
};
protected:
TMVA::Ranking*TMVA::MethodBase::fRankingranking
vector<TString>*TMVA::MethodBase::fInputVarsvector of input variables used in MVA
Bool_tTMVA::MethodBase::fIsOKstatus of sanity checks
TH1*TMVA::MethodBase::fHistS_plotbinMVA plots used for graphics representation (signal)
TH1*TMVA::MethodBase::fHistB_plotbinMVA plots used for graphics representation (background)
TH1*TMVA::MethodBase::fHistS_highbinMVA plots used for efficiency calculations (signal)
TH1*TMVA::MethodBase::fHistB_highbinMVA plots used for efficiency calculations (background)
TH1*TMVA::MethodBase::fEffSefficiency plot (signal)
TH1*TMVA::MethodBase::fEffBefficiency plot (background)
TH1*TMVA::MethodBase::fEffBvsSbackground efficiency versus signal efficiency
TH1*TMVA::MethodBase::fRejBvsSbackground rejection (=1-eff.) versus signal efficiency
TH1*TMVA::MethodBase::fHistBhatSworking histograms needed for mu-transform (signal)
TH1*TMVA::MethodBase::fHistBhatBworking histograms needed for mu-transform (background)
TH1*TMVA::MethodBase::fHistMuSmu-transform (signal)
TH1*TMVA::MethodBase::fHistMuBmu-transform (background)
TH1*TMVA::MethodBase::fTrainEffSTraining efficiency plot (signal)
TH1*TMVA::MethodBase::fTrainEffBTraining efficiency plot (background)
TH1*TMVA::MethodBase::fTrainEffBvsSTraining background efficiency versus signal efficiency
TH1*TMVA::MethodBase::fTrainRejBvsSTraining background rejection (=1-eff.) versus signal efficiency
Double_tTMVA::MethodBase::fX
Double_tTMVA::MethodBase::fMode
TGraph*TMVA::MethodBase::fGraphSgraphs used for splines for efficiency (signal)
TGraph*TMVA::MethodBase::fGraphBgraphs used for splines for efficiency (background)
TGraph*TMVA::MethodBase::fGrapheffBvsSgraphs used for splines for signal eff. versus background eff.
TMVA::PDF*TMVA::MethodBase::fSplSPDFs of MVA distribution (signal)
TMVA::PDF*TMVA::MethodBase::fSplBPDFs of MVA distribution (background)
TSpline*TMVA::MethodBase::fSpleffBvsSsplines for signal eff. versus background eff.
TGraph*TMVA::MethodBase::fGraphTrainSgraphs used for splines for training efficiency (signal)
TGraph*TMVA::MethodBase::fGraphTrainBgraphs used for splines for training efficiency (background)
TGraph*TMVA::MethodBase::fGraphTrainEffBvsSgraphs used for splines for training signal eff. versus background eff.
TMVA::PDF*TMVA::MethodBase::fSplTrainSPDFs of training MVA distribution (signal)
TMVA::PDF*TMVA::MethodBase::fSplTrainBPDFs of training MVA distribution (background)
TSpline*TMVA::MethodBase::fSplTrainEffBvsSsplines for training signal eff. versus background eff.
Int_tTMVA::MethodBase::fNbinsnumber of bins in representative histograms
Int_tTMVA::MethodBase::fNbinsHnumber of bins in evaluation histograms
TMVA::MethodBase::ECutOrientationTMVA::MethodBase::fCutOrientation+1 if Sig>Bkg, -1 otherwise
TMVA::TSpline1*TMVA::MethodBase::fSplRefShelper splines for RootFinder (signal)
TMVA::TSpline1*TMVA::MethodBase::fSplRefBhelper splines for RootFinder (background)
TMVA::TSpline1*TMVA::MethodBase::fSplTrainRefShelper splines for RootFinder (signal)
TMVA::TSpline1*TMVA::MethodBase::fSplTrainRefBhelper splines for RootFinder (background)
TMVA::OptionBase*TMVA::MethodBase::fLastDeclaredOptionlast declared option
TListTMVA::MethodBase::fListOfOptionsoption list
TMVA::MsgLoggerTMVA::MethodBase::fLoggermessage logger
private:
Int_tfSplineSpline order to smooth histograms
Int_tfAverageEvtPerBinaverage events per bin; used to calculate fNbins
TMVA::PDF::ESmoothMethodfSmoothMethod
TFile*fFin
Int_tfNsmoothnaumber of smooth passes
Double_tfEpsilonminimum number of likelihood (to avoid zero)
Bool_tfTransformLikelihoodOutputlikelihood output is sigmoid-transformed
vector<TH1*>*fHistSigsignal PDFs (histograms)
vector<TH1*>*fHistBgdbackground PDFs (histograms)
vector<TH1*>*fHistSig_smoothsignal PDFs (smoothed histograms)
vector<TH1*>*fHistBgd_smoothbackground PDFs (smoothed histograms)
TList*fSigPDFHistlist of PDF histograms (signal)
TList*fBgdPDFHistlist of PDF histograms (background)
vector<UInt_t>*fIndexSigused for caching in GetMvaValue
vector<UInt_t>*fIndexBgdused for caching in GetMvaValue
vector<PDF*>*fPDFSiglist of PDFs (signal)
vector<PDF*>*fPDFBgdlist of PDFs (background)

Class Description


/*
  Likelihood analysis ("non-parametric approach")                      
  
  

Also implemented is a "diagonalized likelihood approach", which improves over the uncorrelated likelihood ansatz by transforming linearly the input variables into a diagonal space, using the square-root of the covariance matrix

The method of maximum likelihood is the most straightforward, and certainly among the most elegant multivariate analyser approaches. We define the likelihood ratio, RL, for event i, by:

Here the signal and background likelihoods, LS, LB, are products of the corresponding probability densities, pS, pB, of the Nvar discriminating variables used in the MVA:
and accordingly for LB. In practise, TMVA uses polynomial splines to estimate the probability density functions (PDF) obtained from the distributions of the training variables.

Note that in TMVA the output of the likelihood ratio is transformed by

to avoid the occurrence of heavy peaks at RL=0,1. Decorrelated (or "diagonalized") Likelihood

The biggest drawback of the Likelihood approach is that it assumes that the discriminant variables are uncorrelated. If it were the case, it can be proven that the discrimination obtained by the above likelihood ratio is optimal, ie, no other method can beat it. However, in most practical applications of MVAs correlations are present.

Linear correlations, measured from the training sample, can be taken into account in a straightforward manner through the square-root of the covariance matrix. The square-root of a matrix C is the matrix C′ that multiplied with itself yields C: C=C′C′. We compute the square-root matrix (SQM) by means of diagonalising (D) the covariance matrix:

and the linear transformation of the linearly correlated into the uncorrelated variables space is then given by multiplying the measured variable tuple by the inverse of the SQM. Note that these transformations are performed for both signal and background separately, since the correlation pattern is not the same in the two samples.

The above diagonalisation is complete for linearly correlated, Gaussian distributed variables only. In real-world examples this is not often the case, so that only little additional information may be recovered by the diagonalisation procedure. In these cases, non-linear methods must be applied. */

_______________________________________________________________________
MethodLikelihood( TString jobName, TString methodTitle, DataSet& theData, TString theOption, TDirectory* theTargetDir )
 standard constructor

 MethodLikelihood options:
 format and syntax of option string: "Spline2:0:25:D"

 where:
  SplineI [I=0,12,3,5] - which spline is used for smoothing the pdfs
                    0  - how often the input histos are smoothed
                    25 - average num of events per PDF bin to trigger warning
                    D  - use square-root-matrix to decorrelate variable space 
 
MethodLikelihood( DataSet& theData, TString theWeightFile, TDirectory* theTargetDir )
 construct likelihood references from file
void InitLik( void )
 default initialisation called by all constructors
void DeclareOptions()
 define the options (their key words) that can be set in the option string 
 know options:
 Spline            <int>    spline used to interpolate reference histograms
    available values are:        0, 1, 2 <default>, 3, 5

 NSmooth           <int>    how often the input histos are smoothed
 NAvEvtPerBin      <int>    minimum average number of events per PDF bin (less trigger warning)
 TransformOutput   <bool>   transform (often strongly peaked) likelihood output through sigmoid inversion
void ProcessOptions()
 process user options
~MethodLikelihood( void )
 destructor  
void Train( void )
 create reference distributions (PDFs) from signal and background events:
 fill histograms and smooth them; if decorrelation is required, compute 
 corresponding square-root matrices
Double_t GetMvaValue()
 returns the likelihood estimator for signal
void WriteWeightsToStream( ostream& o )
 write reference PDFs to file
void ReadWeightsFromStream( istream& istr )
 read reference PDFs from file   if (istr.eof());
void WriteMonitoringHistosToFile( void )
 write histograms and PDFs to file for monitoring purposes
const Ranking* CreateRanking()
 ranking of input variables
{ return 0; }
Bool_t ReadTestEvent(UInt_t ievt, Types::ESBType type = Types::kSignal)
 overload test event reading

Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss
Last update: root/tmva $Id: MethodLikelihood.cxx,v 1.12 2006/11/20 15:35:28 brun Exp $
Copyright (c) 2005: *


ROOT page - Class index - Class Hierarchy - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.