class TMVA::RuleFit

library: libTMVA
#include "TMVA/RuleFit.h"

Display options:

[ ↑ Top ] | [ ? Help ]

Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file source file viewVC header viewVC source

Sections: class description function members data members class charts

ROOT » TMVA » TMVA::RuleFit

class TMVA::RuleFit

Function Members (Methods)

public:

virtual	~RuleFit()
void	Boost(TMVA::DecisionTree* dt)
void	BuildTree(TMVA::DecisionTree* dt)
void	CalcImportance()
Double_t	CalcWeightSum(const vector<const TMVA::Event> events, UInt_t neve = 0)
static TClass*	Class()
Double_t	EvalEvent(const TMVA::Event& e)
void	FillCorr(TH2F* h2, const TMVA::Rule* rule, Int_t v1, Int_t v2)
void	FillCut(TH2F* h2, const TMVA::Rule* rule, Int_t vind)
void	FillLin(TH2F* h2, Int_t vind)
void	FillVisHistCorr(const TMVA::Rule* rule, vector<TH2F*>& hlist)
void	FillVisHistCut(const TMVA::Rule* rule, vector<TH2F*>& hlist)
void	FitCoefficients()
void	ForestStatistics()
Bool_t	GetCorrVars(TString& title, TString& var1, TString& var2)
const vector<const TMVA::DecisionTree*>&	GetForest() const
const TMVA::MethodBase*	GetMethodBase() const
const TMVA::MethodRuleFit*	GetMethodRuleFit() const
Double_t	GetNEveEff() const
UInt_t	GetNTreeSample() const
void	GetRndmSampleEvents(vector<const TMVA::Event*>& evevec, UInt_t nevents)
const TMVA::RuleEnsemble&	GetRuleEnsemble() const
TMVA::RuleEnsemble*	GetRuleEnsemblePtr()
const TMVA::RuleFitParams&	GetRuleFitParams() const
TMVA::RuleFitParams*	GetRuleFitParamsPtr()
const TMVA::Event*	GetTrainingEvent(UInt_t i) const
const vector<const TMVA::Event*>&	GetTrainingEvents() const
Double_t	GetTrainingEventWeight(UInt_t i) const
void	Initialize(const TMVA::MethodBase* rfbase)
void	InitNEveEff()
void	InitPtrs(const TMVA::MethodBase* rfbase)
virtual TClass*	IsA() const
void	MakeDebugHists()
void	MakeForest()
void	MakeVisHists()
void	NormVisHists(vector<TH2F*>& hlist)
TMVA::RuleFit&	operator=(const TMVA::RuleFit&)
void	ReshuffleEvents()
void	RestoreEventWeights()
TMVA::RuleFit	RuleFit()
TMVA::RuleFit	RuleFit(const TMVA::MethodBase* rfbase)
void	SaveEventWeights()
void	SetGDNPathSteps(Int_t n = 100)
void	SetGDPathStep(Double_t s = 0.01)
void	SetGDTau(Double_t t = 0.)
void	SetImportanceCut(Double_t minimp = 0)
void	SetMethodBase(const TMVA::MethodBase* rfbase)
void	SetModelFull()
void	SetModelLinear()
void	SetModelRules()
void	SetMsgType(TMVA::EMsgType t)
void	SetRuleMinDist(Double_t d)
void	SetTrainingEvents(const vector<const TMVA::Event*>& el)
void	SetVisHistsUseImp(Bool_t f)
virtual void	ShowMembers(TMemberInspector& insp) const
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
void	UseCoefficientsVisHists()
void	UseImportanceVisHists()

private:

void	Copy(const TMVA::RuleFit& other)
TMVA::MsgLogger&	Log() const
TMVA::RuleFit	RuleFit(const TMVA::RuleFit& other)

Data Members

private:

vector<Double_t>	fEventWeights	original weights of the events - follows fTrainingEvents
vector<const TMVA::DecisionTree*>	fForest	the input forest of decision trees
TMVA::MsgLogger*	fLogger	message logger
const TMVA::MethodBase*	fMethodBase	pointer the method base which initialized this RuleFit instance
const TMVA::MethodRuleFit*	fMethodRuleFit	pointer the method which initialized this RuleFit instance
Double_t	fNEveEffTrain	reweighted number of events = sum(wi)
UInt_t	fNTreeSample	number of events in sub sample = frac*neve
TMVA::RuleEnsemble	fRuleEnsemble	the ensemble of rules
TMVA::RuleFitParams	fRuleFitParams	fit rule parameters
vector<const TMVA::Event*>	fTrainingEvents	all training events
vector<const TMVA::Event*>	fTrainingEventsRndm	idem, but randomly shuffled
Bool_t	fVisHistsUseImp	if true, use importance as weight; else coef in vis hists
static const Int_t	randSEED	set to 1 for debugging purposes or to zero for random seeds

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

RuleFit( const MethodBase *rfbase )

 constructor

RuleFit()

 default constructor

~RuleFit()

 destructor

void InitNEveEff()

 init effective number of events (using event weights)

void InitPtrs(const TMVA::MethodBase* rfbase)

 initialize pointers

void Initialize(const TMVA::MethodBase* rfbase)

 initialize the parameters of the RuleFit method and make rules

void SetMethodBase(const TMVA::MethodBase* rfbase)

 set MethodBase

void Copy(const TMVA::RuleFit& other)

 copy method

Double_t CalcWeightSum(const vector<const TMVA::Event*>* events, UInt_t neve = 0)

 calculate the sum of weights

void SetMsgType(TMVA::EMsgType t)

 set the current message type to that of mlog for this class and all other subtools

void BuildTree(TMVA::DecisionTree* dt)

 build the decision tree using fNTreeSample events from fTrainingEventsRndm

void MakeForest()

 make a forest of decisiontrees

void SaveEventWeights()

 save event weights - must be done before making the forest

void RestoreEventWeights()

 save event weights - must be done before making the forest

void Boost(TMVA::DecisionTree* dt)

 Boost the events. The algorithm below is the called AdaBoost.
 See MethodBDT for details.
 Actually, this is a more or less copy of MethodBDT::AdaBoost().

void ForestStatistics()

 summary of statistics of all trees
 * end-nodes: average and spread

void FitCoefficients()

 Fit the coefficients for the rule ensemble

void CalcImportance()

 calculates the importance of each rule

Double_t EvalEvent(const TMVA::Event& e)

 evaluate single event

void SetTrainingEvents(const vector<const TMVA::Event*>& el)

 set the training events randomly

void GetRndmSampleEvents(vector<const TMVA::Event*>& evevec, UInt_t nevents)

 draw a random subsample of the training events without replacement

void NormVisHists(vector<TH2F*>& hlist)

 normalize rule importance hists

 if all weights are positive, the scale will be 1/maxweight
 if minimum weight < 0, then the scale will be 1/max(maxweight,abs(minweight))

void FillCut(TH2F* h2, const TMVA::Rule* rule, Int_t vind)

 Fill cut

void FillLin(TH2F* h2, Int_t vind)

 fill lin

void FillCorr(TH2F* h2, const TMVA::Rule* rule, Int_t v1, Int_t v2)

 fill rule correlation between vx and vy, weighted with either the importance or the coefficient

void FillVisHistCut(const TMVA::Rule* rule, vector<TH2F*>& hlist)

 help routine to MakeVisHists() - fills for all variables

void FillVisHistCorr(const TMVA::Rule* rule, vector<TH2F*>& hlist)

 help routine to MakeVisHists() - fills for all correlation plots

Bool_t GetCorrVars(TString& title, TString& var1, TString& var2)

 get first and second variables from title

void MakeVisHists()

 this will create histograms visualizing the rule ensemble

void MakeDebugHists()

 this will create a histograms intended rather for debugging or for the curious user

RuleFit(const TMVA::MethodBase* rfbase)

 main constructor

void ReshuffleEvents()

{ std::random_shuffle(fTrainingEventsRndm.begin(),fTrainingEventsRndm.end()); }

void SetModelLinear()

 set usage of linear term

{ fRuleEnsemble.SetModelLinear(); }

void SetModelRules()

 set usage of rules

{ fRuleEnsemble.SetModelRules(); }

void SetModelFull()

 set usage of linear term

{ fRuleEnsemble.SetModelFull(); }

void SetImportanceCut(Double_t minimp = 0)

 set minimum importance allowed

{ fRuleEnsemble.SetImportanceCut(minimp); }

void SetRuleMinDist(Double_t d)

 set minimum rule distance - see RuleEnsemble

{ fRuleEnsemble.SetRuleMinDist(d); }

void SetGDTau(Double_t t = 0.)

 set path related parameters

{ fRuleFitParams.SetGDTau(t); }

void SetGDPathStep(Double_t s = 0.01)

{ fRuleFitParams.SetGDPathStep(s); }

void SetGDNPathSteps(Int_t n = 100)

 make visualization histograms

{ fRuleFitParams.SetGDNPathSteps(n); }

void SetVisHistsUseImp(Bool_t f)

{ fVisHistsUseImp = f; }

void UseImportanceVisHists()

{ fVisHistsUseImp = kTRUE; }

void UseCoefficientsVisHists()

{ fVisHistsUseImp = kFALSE; }

UInt_t GetNTreeSample() const

 accessors

{ return fNTreeSample; }

Double_t GetNEveEff() const

{ return fNEveEffTrain; }

const Event* GetTrainingEvent(UInt_t i) const

{ return static_cast< const Event *>(fTrainingEvents[i]); }

Double_t GetTrainingEventWeight(UInt_t i) const

{ return fTrainingEvents[i]->GetWeight(); }

const std::vector< const TMVA::Event * > & GetTrainingEvents() const

      const Event*  GetTrainingEvent(UInt_t i, UInt_t isub)  const { return &(fTrainingEvents[fSubsampleEvents[isub]])[i]; }

{ return fTrainingEvents; }

const std::vector< const TMVA::DecisionTree *> & GetForest() const

{ return fForest; }

const RuleEnsemble & GetRuleEnsemble() const

{ return fRuleEnsemble; }

RuleEnsemble * GetRuleEnsemblePtr()

{ return &fRuleEnsemble; }

const RuleFitParams & GetRuleFitParams() const

{ return fRuleFitParams; }

RuleFitParams * GetRuleFitParamsPtr()

{ return &fRuleFitParams; }

const MethodRuleFit * GetMethodRuleFit() const

{ return fMethodRuleFit; }

const MethodBase * GetMethodBase() const

{ return fMethodBase; }