/usr/include/root/TMVA/MethodMLP.h is in libroot-tmva-dev 5.34.30-0ubuntu8.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | // @(#)root/tmva $Id$
// Author: Krzysztof Danielowski, Andreas Hoecker, Matt Jachowski, Kamil Kraszewski, Maciej Kruk, Peter Speckmayer, Joerg Stelzer, Eckhard von Toerne, Jan Therhaag, Jiahang Zhong
/**********************************************************************************
* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
* Package: TMVA *
* Class : MethodMLP *
* Web : http://tmva.sourceforge.net *
* *
* Description: *
* ANN Multilayer Perceptron class for the discrimination of signal *
* from background. BFGS implementation based on TMultiLayerPerceptron *
* class from ROOT (http://root.cern.ch). *
* *
* Authors (alphabetical): *
* Krzysztof Danielowski <danielow@cern.ch> - IFJ & AGH, Poland *
* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
* Matt Jachowski <jachowski@stanford.edu> - Stanford University, USA *
* Kamil Kraszewski <kalq@cern.ch> - IFJ & UJ, Poland *
* Maciej Kruk <mkruk@cern.ch> - IFJ & AGH, Poland *
* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *
* Joerg Stelzer <stelzer@cern.ch> - DESY, Germany *
* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany *
* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany *
* Jiahang Zhong <Jiahang.Zhong@cern.ch> - Academia Sinica, Taipei *
* *
* Copyright (c) 2005-2011: *
* CERN, Switzerland *
* U. of Victoria, Canada *
* MPI-K Heidelberg, Germany *
* U. of Bonn, Germany *
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted according to the terms listed in LICENSE *
* (http://tmva.sourceforge.net/LICENSE) *
**********************************************************************************/
#ifndef ROOT_TMVA_MethodMLP
#define ROOT_TMVA_MethodMLP
//////////////////////////////////////////////////////////////////////////
// //
// MethodMLP //
// //
// Multilayer Perceptron built off of MethodANNBase //
// //
//////////////////////////////////////////////////////////////////////////
#include <vector>
#ifndef ROOT_TString
#include "TString.h"
#endif
#ifndef ROOT_TTree
#include "TTree.h"
#endif
#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif
#ifndef ROOT_TRandom3
#include "TRandom3.h"
#endif
#ifndef ROOT_TH1F
#include "TH1F.h"
#endif
#ifndef ROOT_TMatrixDfwd
#include "TMatrixDfwd.h"
#endif
#ifndef ROOT_TMVA_IFitterTarget
#include "TMVA/IFitterTarget.h"
#endif
#ifndef ROOT_TMVA_MethodBase
#include "TMVA/MethodBase.h"
#endif
#ifndef ROOT_TMVA_MethodANNBase
#include "TMVA/MethodANNBase.h"
#endif
#ifndef ROOT_TMVA_TNeuron
#include "TMVA/TNeuron.h"
#endif
#ifndef ROOT_TMVA_TActivation
#include "TMVA/TActivation.h"
#endif
#ifndef ROOT_TMVA_ConvergenceTest
#include "TMVA/ConvergenceTest.h"
#endif
#define MethodMLP_UseMinuit__
#undef MethodMLP_UseMinuit__
namespace TMVA {
class MethodMLP : public MethodANNBase, public IFitterTarget, public ConvergenceTest {
public:
// standard constructors
MethodMLP( const TString& jobName,
const TString& methodTitle,
DataSetInfo& theData,
const TString& theOption,
TDirectory* theTargetDir = 0 );
MethodMLP( DataSetInfo& theData,
const TString& theWeightFile,
TDirectory* theTargetDir = 0 );
virtual ~MethodMLP();
virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets );
void Train() { Train(NumCycles()); }
// for GA
Double_t ComputeEstimator ( std::vector<Double_t>& parameters );
Double_t EstimatorFunction( std::vector<Double_t>& parameters );
enum ETrainingMethod { kBP=0, kBFGS, kGA };
enum EBPTrainingMode { kSequential=0, kBatch };
bool HasInverseHessian() { return fCalculateErrors; }
Double_t GetMvaValue( Double_t* err=0, Double_t* errUpper=0 );
protected:
// make ROOT-independent C++ class for classifier response (classifier-specific implementation)
void MakeClassSpecific( std::ostream&, const TString& ) const;
// get help message text
void GetHelpMessage() const;
private:
// the option handling methods
void DeclareOptions();
void ProcessOptions();
// general helper functions
void Train( Int_t nEpochs );
void Init();
void InitializeLearningRates(); // although this is only needed by backprop
// used as a measure of success in all minimization techniques
Double_t CalculateEstimator( Types::ETreeType treeType = Types::kTraining, Int_t iEpoch = -1 );
// BFGS functions
void BFGSMinimize( Int_t nEpochs );
void SetGammaDelta( TMatrixD &Gamma, TMatrixD &Delta, std::vector<Double_t> &Buffer );
void SteepestDir( TMatrixD &Dir );
Bool_t GetHessian( TMatrixD &Hessian, TMatrixD &Gamma, TMatrixD &Delta );
void SetDir( TMatrixD &Hessian, TMatrixD &Dir );
Double_t DerivDir( TMatrixD &Dir );
Bool_t LineSearch( TMatrixD &Dir, std::vector<Double_t> &Buffer, Double_t* dError=0 ); //zjh
void ComputeDEDw();
void SimulateEvent( const Event* ev );
void SetDirWeights( std::vector<Double_t> &Origin, TMatrixD &Dir, Double_t alpha );
Double_t GetError();
Double_t GetMSEErr( const Event* ev, UInt_t index = 0 ); //zjh
Double_t GetCEErr( const Event* ev, UInt_t index = 0 ); //zjh
// backpropagation functions
void BackPropagationMinimize( Int_t nEpochs );
void TrainOneEpoch();
void Shuffle( Int_t* index, Int_t n );
void DecaySynapseWeights(Bool_t lateEpoch );
void TrainOneEvent( Int_t ievt);
Double_t GetDesiredOutput( const Event* ev );
void UpdateNetwork( Double_t desired, Double_t eventWeight=1.0 );
void UpdateNetwork(const std::vector<Float_t>& desired, Double_t eventWeight=1.0);
void CalculateNeuronDeltas();
void UpdateSynapses();
void AdjustSynapseWeights();
// faster backpropagation
void TrainOneEventFast( Int_t ievt, Float_t*& branchVar, Int_t& type );
// genetic algorithm functions
void GeneticMinimize();
#ifdef MethodMLP_UseMinuit__
// minuit functions -- commented out because they rely on a static pointer
void MinuitMinimize();
static MethodMLP* GetThisPtr();
static void IFCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t* fitPars, Int_t ifl );
void FCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t* fitPars, Int_t ifl );
#endif
// general
bool fUseRegulator; // zjh
bool fCalculateErrors; // compute inverse hessian matrix at the end of the training
Double_t fPrior; // zjh
std::vector<Double_t> fPriorDev; // zjh
void GetApproxInvHessian ( TMatrixD& InvHessian, bool regulate=true ); //rank-1 approximation, neglect 2nd derivatives. //zjh
void UpdateRegulators(); // zjh
void UpdatePriors(); // zjh
Int_t fUpdateLimit; // zjh
ETrainingMethod fTrainingMethod; // method of training, BP or GA
TString fTrainMethodS; // training method option param
Float_t fSamplingFraction; // fraction of events which is sampled for training
Float_t fSamplingEpoch; // fraction of epochs where sampling is used
Float_t fSamplingWeight; // changing factor for event weights when sampling is turned on
Bool_t fSamplingTraining; // The training sample is sampled
Bool_t fSamplingTesting; // The testing sample is sampled
// BFGS variables
Double_t fLastAlpha; // line search variable
Double_t fTau; // line search variable
Int_t fResetStep; // reset time (how often we clear hessian matrix)
// backpropagation variable
Double_t fLearnRate; // learning rate for synapse weight adjustments
Double_t fDecayRate; // decay rate for above learning rate
EBPTrainingMode fBPMode; // backprop learning mode (sequential or batch)
TString fBpModeS; // backprop learning mode option string (sequential or batch)
Int_t fBatchSize; // batch size, only matters if in batch learning mode
Int_t fTestRate; // test for overtraining performed at each #th epochs
Bool_t fEpochMon; // create and fill epoch-wise monitoring histograms (makes outputfile big!)
// genetic algorithm variables
Int_t fGA_nsteps; // GA settings: number of steps
Int_t fGA_preCalc; // GA settings: number of pre-calc steps
Int_t fGA_SC_steps; // GA settings: SC_steps
Int_t fGA_SC_rate; // GA settings: SC_rate
Double_t fGA_SC_factor; // GA settings: SC_factor
// regression, storage of deviations
std::vector<std::pair<Float_t,Float_t> >* fDeviationsFromTargets; // deviation from the targets, event weight
Float_t fWeightRange; // suppress outliers for the estimator calculation
#ifdef MethodMLP_UseMinuit__
// minuit variables -- commented out because they rely on a static pointer
Int_t fNumberOfWeights; // Minuit: number of weights
static MethodMLP* fgThis; // Minuit: this pointer
#endif
// debugging flags
static const Int_t fgPRINT_ESTIMATOR_INC = 10; // debug flags
static const Bool_t fgPRINT_SEQ = kFALSE; // debug flags
static const Bool_t fgPRINT_BATCH = kFALSE; // debug flags
ClassDef(MethodMLP,0) // Multi-layer perceptron implemented specifically for TMVA
};
} // namespace TMVA
#endif
|