Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file inheritance tree (.pdf)

Sections: class description function members data members class charts

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 Chart:

TMVA::RuleFit

Function documentation

RuleFit(const TMVA::MethodBase* rfbase)

 main constructor

RuleFit(const TMVA::RuleFit& other)

 empty constructor

virtual ~RuleFit( void )

void InitNEveEff()

void InitPtrs(const TMVA::MethodBase* rfbase)

void Initialize(const TMVA::MethodBase* rfbase)

void SetMsgType(TMVA::EMsgType t)

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

void ReshuffleEvents()

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

void SetMethodBase(const TMVA::MethodBase* rfbase)

void MakeForest()

 make the forest of trees for rule generation

void BuildTree(TMVA::DecisionTree* dt)

 build a tree

void SaveEventWeights()

 save event weights

void RestoreEventWeights()

 restore saved event weights

void Boost(TMVA::DecisionTree* dt)

 boost events based on the given tree

void ForestStatistics()

 calculate and print some statistics on the given forest

Double_t EvalEvent(const TMVA::Event& e)

 calculate the discriminating variable for the given event

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

 calculate sum of

void FitCoefficients()

 do the fitting of the coefficients

void CalcImportance()

 calculate variable and rule importance from a set of events

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; }

void MakeVisHists()

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

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

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

void FillLin(TH2F* h2, Int_t vind)

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

void NormVisHists(vector<TH2F*>& hlist)

void MakeDebugHists()

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

 accessors

UInt_t GetNTreeSample() const

{ 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; }

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

      const std::vector< Int_t >               & GetSubsampleEvents() const { return fSubsampleEvents; }
      void  GetSubsampleEvents(Int_t sub, UInt_t & ibeg, UInt_t & iend) const;

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; }

RuleFit( const RuleFit & other )

 copy constructor

void Copy(const TMVA::RuleFit& other)

 copy method