library: libTMVA
#include "MethodCFMlpANN.h"

TMVA::MethodCFMlpANN


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

class TMVA::MethodCFMlpANN: public TMVA::MethodBase, public TMVA::MethodCFMlpANN_Utils

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
virtual~MethodCFMlpANN()
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
Int_tGetClass(Int_t ivar) const
Double_tGetData(Int_t isel, Int_t ivar) 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::MethodCFMlpANNMethodCFMlpANN(TMVA::DataSet& theData, TString theWeightFile, TDirectory* theTargetDir = NULL)
TMVA::MethodCFMlpANNMethodCFMlpANN(TString jobName, TString methodTitle, TMVA::DataSet& theData, TString theOption = 3000:N-1:N-2, 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_tTMVA::MethodBase::ReadTestEvent(UInt_t ievt, TMVA::Types::ESBType type = Types::kMaxSBType)
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)
static TMVA::MethodCFMlpANN*This()
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 voidTMVA::MethodBase::WriteMonitoringHistosToFile() 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 Int_tDataInterface(Double_t*, Double_t*, Int_t*, Int_t*, Int_t*, Int_t*, Double_t*, Int_t*, Int_t*)
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)
virtual voidWriteNNWeightsToStream(ostream&, Int_t, Int_t, const Double_t*, const Double_t*, Int_t, const Int_t*, const Double_t*, const Double_t*, const Double_t*) const
voidTMVA::MethodBase::WriteOptionsToStream(ostream& o) const
private:
voidTMVA::MethodCFMlpANN_Utils::Arret(const char* mot)
voidTMVA::MethodCFMlpANN_Utils::CollectVar(Int_t* nvar, Int_t* class__, Double_t* xpg)
voidTMVA::MethodCFMlpANN_Utils::Cout(Int_t*, Double_t* xxx)
voidTMVA::MethodCFMlpANN_Utils::Cout2(Int_t*, Double_t* yyy)
virtual voidDeclareOptions()
voidTMVA::MethodCFMlpANN_Utils::En_arriere(Int_t* ievent)
voidTMVA::MethodCFMlpANN_Utils::En_avant(Int_t* ievent)
voidTMVA::MethodCFMlpANN_Utils::En_avant2(Int_t* ievent)
voidTMVA::MethodCFMlpANN_Utils::Entree_new(Int_t*, char*, Int_t* ntrain, Int_t* ntest, Int_t* numlayer, Int_t* nodes, Int_t* numcycle, Int_t)
Double_tEvalANN(vector<Double_t>*, Bool_t& isOK)
Double_tTMVA::MethodCFMlpANN_Utils::Fdecroi(Int_t* i__)
voidTMVA::MethodCFMlpANN_Utils::Foncf(Int_t* i__, Double_t* u, Double_t* f)
voidTMVA::MethodCFMlpANN_Utils::GraphNN(Int_t* ilearn, Double_t*, Double_t*, char*, Int_t)
voidInitCFMlpANN()
voidTMVA::MethodCFMlpANN_Utils::Inl()
voidTMVA::MethodCFMlpANN_Utils::Innit(char* det, Double_t* tout2, Double_t* tin2, Int_t)
voidTMVA::MethodCFMlpANN_Utils::Lecev2(Int_t* ktest, Double_t* tout2, Double_t* tin2)
voidTMVA::MethodCFMlpANN_Utils::Leclearn(Int_t* ktest, Double_t* tout2, Double_t* tin2)
voidNN_ava(Double_t*)
Double_tNN_fonc(Int_t, Double_t) const
voidTMVA::MethodCFMlpANN_Utils::Out(Int_t* iii, Int_t* maxcycle)
virtual voidProcessOptions()
Double_tTMVA::MethodCFMlpANN_Utils::Sen3a()
voidTMVA::MethodCFMlpANN_Utils::TestNN()
voidTMVA::MethodCFMlpANN_Utils::Train_nn(Double_t* tin2, Double_t* tout2, Int_t* ntrain, Int_t* ntest, Int_t* nvar2, Int_t* nlayer, Int_t* nodes, Int_t* ncycle)
voidTMVA::MethodCFMlpANN_Utils::Wini()

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:
static TMVA::MethodCFMlpANN*fgThisthis carrier
TMatrix*fDatathe (data,var) string
vector<Int_t>*fClassthe event class (1=signal, 2=background)
Int_tfNlayersnumber of layers (including input and output layers)
Int_tfNcyclesnumber of training cycles
Int_t*fNodesnumber of nodes per layer
Double_t*fXmaxNNmaximum values of input variables
Double_t*fXminNNminimum values of input variables
Int_tfLayermNNnumber of layers (including input and output layers)
Int_t*fNeuronNNnodes per layer
Double_t***fWNNweights
Double_t**fWwNNweights
Double_t**fYNNweights
Double_t*fTempNNtemperature (used in activation function)
TStringfLayerSpecthe hidden layer specification string
static Int_tTMVA::MethodCFMlpANN_Utils::fg_100constant
static Int_tTMVA::MethodCFMlpANN_Utils::fg_0constant
static Int_tTMVA::MethodCFMlpANN_Utils::fg_max_nVar_static maximum number of input variables
static Int_tTMVA::MethodCFMlpANN_Utils::fg_max_nNodes_maximum number of nodes per variable
static Int_tTMVA::MethodCFMlpANN_Utils::fg_999constant
TMVA::MethodCFMlpANN_Utils::TMVA::MethodCFMlpANN_Utils::fParam_1
TMVA::MethodCFMlpANN_Utils::TMVA::MethodCFMlpANN_Utils::fVarn_1
TMVA::MethodCFMlpANN_Utils::TMVA::MethodCFMlpANN_Utils::fVarn2_1
TMVA::MethodCFMlpANN_Utils::TMVA::MethodCFMlpANN_Utils::fVarn3_1
TMVA::MethodCFMlpANN_Utils::TMVA::MethodCFMlpANN_Utils::neur_1
TMVA::MethodCFMlpANN_Utils::TMVA::MethodCFMlpANN_Utils::fDel_1
TMVA::MethodCFMlpANN_Utils::TMVA::MethodCFMlpANN_Utils::fCost_1

Class Description

                                                                      
 
/* Interface to Clermond-Ferrand artificial neural network

The CFMlpANN belong to the class of Multilayer Perceptrons (MLP), which are feed-forward networks according to the following propagation schema:

Schema for artificial neural network
The input layer contains as many neurons as input variables used in the MVA. The output layer contains two neurons for the signal and background event classes. In between the input and output layers are a variable number of k hidden layers with arbitrary numbers of neurons. (While the structure of the input and output layers is determined by the problem, the hidden layers can be configured by the user through the option string of the method booking.)
As indicated in the sketch, all neuron inputs to a layer are linear combinations of the neuron output of the previous layer. The transfer from input to output within a neuron is performed by means of an "activation function". In general, the activation function of a neuron can be zero (deactivated), one (linear), or non-linear. The above example uses a sigmoid activation function. The transfer function of the output layer is usually linear. As a consequence: an ANN without hidden layer should give identical discrimination power as a linear discriminant analysis (Fisher). In case of one hidden layer, the ANN computes a linear combination of sigmoid.
The learning method used by the CFMlpANN is only stochastic. */
_______________________________________________________________________
MethodCFMlpANN( TString jobName, TString methodTitle, DataSet& theData, TString theOption, TDirectory* theTargetDir )
 standard constructor
 option string: "n_training_cycles:n_hidden_layers"  
 default is:  n_training_cycles = 5000, n_layers = 4 

 * note that the number of hidden layers in the NN is: 
   n_hidden_layers = n_layers - 2

 * since there is one input and one output layer. The number of         
   nodes (neurons) is predefined to be:
   n_nodes[i] = nvars + 1 - i (where i=1..n_layers)                  

   with nvars being the number of variables used in the NN.             

 Hence, the default case is: n_neurons(layer 1 (input)) : nvars       
                             n_neurons(layer 2 (hidden)): nvars-1     
                             n_neurons(layer 3 (hidden)): nvars-1     
                             n_neurons(layer 4 (out))   : 2           

 This artificial neural network usually needs a relatively large      
 number of cycles to converge (8000 and more). Overtraining can       
 be efficienctly tested by comparing the signal and background        
 output of the NN for the events that were used for training and      
 an independent data sample (with equal properties). If the separation
 performance is significantly better for the training sample, the     
 NN interprets statistical effects, and is hence overtrained. In       
 this case, the number of cycles should be reduced, or the size       
 of the training sample increased.                                    

MethodCFMlpANN( DataSet & theData, TString theWeightFile, TDirectory* theTargetDir )
 construction from weight file
void DeclareOptions()
 define the options (their key words) that can be set in the option string 
 know options: NCycles=xx              :the number of training cycles
               HiddenLayser="N-1,N-2"  :the specification of the hidden layers
void ProcessOptions()
 decode the options in the option string
void InitCFMlpANN( void )
 default initialisation called by all constructors
~MethodCFMlpANN( void )
 destructor
void Train( void )
 calls CFMlpANN training
Double_t GetMvaValue()
 returns CFMlpANN output (normalised within [0,1])
Double_t EvalANN( vector<Double_t>* inVar, Bool_t& isOK )
 evaluates NN value as function of input variables
void NN_ava( Double_t* xeev )
 auxiliary functions
Double_t NN_fonc( Int_t i, Double_t u )
 activation function
void WriteWeightsToStream( std::ostream & o )
 write coefficients to file
 not used; weights are saved in TMVA::MethodCFMlpANN_Utils
void ReadWeightsFromStream( istream & istr )
 read back the weight from the training from file (stream)
Int_t DataInterface( Double_t* /*tout2*/, Double_t* /*tin2*/, Int_t* /* icode*/, Int_t* /*flag*/, Int_t* /*nalire*/, Int_t* nvar, Double_t* xpg, Int_t* iclass, Int_t* ikend )
 data interface function 
void WriteNNWeightsToStream( std::ostream & o, Int_t nva, Int_t lclass, const Double_t* xmaxNN, const Double_t* xminNN, Int_t layermNN, const Int_t* neuronNN, const Double_t* wNN, const Double_t* wwNN, const Double_t* tempNN )
 file interface function
Int_t GetClass( Int_t ivar )
{ return (*fClass)[ivar]; }
MethodCFMlpANN* This( void )
 static pointer to this object (required for external functions
{ return fgThis; }
const Ranking* CreateRanking()
 ranking of input variables
{ return 0; }

Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss
Last update: root/tmva $Id: MethodCFMlpANN.cxx,v 1.10 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.