Logo ROOT  
Reference Guide
TMVAClassification.C File Reference

Detailed Description

View in nbviewer Open in SWAN This macro provides examples for the training and testing of the TMVA classifiers.

As input data is used a toy-MC sample consisting of four Gaussian-distributed and linearly correlated input variables. The methods to be used can be switched on and off by means of booleans, or via the prompt command, for example:

root -l ./TMVAClassification.C\(\"Fisher,Likelihood\"\)

(note that the backslashes are mandatory) If no method given, a default set of classifiers is used. The output file "TMVA.root" can be analysed with the use of dedicated macros (simply say: root -l <macro.C>), which can be conveniently invoked through a GUI that will appear at the end of the run of this macro. Launch the GUI via the command:

root -l ./TMVAGui.C

You can also compile and run the example with the following commands

make
./TMVAClassification <Methods>

where: <Methods> = "method1 method2" are the TMVA classifier names example:

./TMVAClassification Fisher LikelihoodPCA BDT

If no method given, a default set is of classifiers is used

  • Project : TMVA - a ROOT-integrated toolkit for multivariate data analysis
  • Package : TMVA
  • Root Macro: TMVAClassification
==> Start TMVAClassification
--- TMVAClassification : Using input file: ./files/tmva_class_example.root
DataSetInfo : [dataset] : Added class "Signal"
: Add Tree TreeS of type Signal with 6000 events
DataSetInfo : [dataset] : Added class "Background"
: Add Tree TreeB of type Background with 6000 events
Factory : Booking method: Cuts
:
: Use optimization method: "Monte Carlo"
: Use efficiency computation method: "Event Selection"
: Use "FSmart" cuts for variable: 'myvar1'
: Use "FSmart" cuts for variable: 'myvar2'
: Use "FSmart" cuts for variable: 'var3'
: Use "FSmart" cuts for variable: 'var4'
Factory : Booking method: CutsD
:
CutsD : [dataset] : Create Transformation "Decorrelate" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
: Use optimization method: "Monte Carlo"
: Use efficiency computation method: "Event Selection"
: Use "FSmart" cuts for variable: 'myvar1'
: Use "FSmart" cuts for variable: 'myvar2'
: Use "FSmart" cuts for variable: 'var3'
: Use "FSmart" cuts for variable: 'var4'
Factory : Booking method: Likelihood
:
Factory : Booking method: LikelihoodPCA
:
LikelihoodPCA : [dataset] : Create Transformation "PCA" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
Factory : Booking method: PDERS
:
Factory : Booking method: PDEFoam
:
Factory : Booking method: KNN
:
Factory : Booking method: LD
:
: Building event vectors for type 2 Signal
: Dataset[dataset] : create input formulas for tree TreeS
: Building event vectors for type 2 Background
: Dataset[dataset] : create input formulas for tree TreeB
DataSetFactory : [dataset] : Number of events in input trees
:
:
: Number of training and testing events
: ---------------------------------------------------------------------------
: Signal -- training events : 1000
: Signal -- testing events : 5000
: Signal -- training and testing events: 6000
: Background -- training events : 1000
: Background -- testing events : 5000
: Background -- training and testing events: 6000
:
DataSetInfo : Correlation matrix (Signal):
: ----------------------------------------
: myvar1 myvar2 var3 var4
: myvar1: +1.000 +0.038 +0.748 +0.922
: myvar2: +0.038 +1.000 -0.058 +0.128
: var3: +0.748 -0.058 +1.000 +0.831
: var4: +0.922 +0.128 +0.831 +1.000
: ----------------------------------------
DataSetInfo : Correlation matrix (Background):
: ----------------------------------------
: myvar1 myvar2 var3 var4
: myvar1: +1.000 -0.021 +0.783 +0.931
: myvar2: -0.021 +1.000 -0.162 +0.057
: var3: +0.783 -0.162 +1.000 +0.841
: var4: +0.931 +0.057 +0.841 +1.000
: ----------------------------------------
DataSetFactory : [dataset] :
:
Factory : Booking method: FDA_GA
:
: Create parameter interval for parameter 0 : [-1,1]
: Create parameter interval for parameter 1 : [-10,10]
: Create parameter interval for parameter 2 : [-10,10]
: Create parameter interval for parameter 3 : [-10,10]
: Create parameter interval for parameter 4 : [-10,10]
: User-defined formula string : "(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3"
: TFormula-compatible formula string: "[0]+[1]*[5]+[2]*[6]+[3]*[7]+[4]*[8]"
Factory : Booking method: MLPBNN
:
MLPBNN : [dataset] : Create Transformation "N" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
MLPBNN : Building Network.
: Initializing weights
Factory : Booking method: DNN_CPU
:
: Parsing option string:
: ... "!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:Layout=TANH|128,TANH|128,TANH|128,LINEAR:TrainingStrategy=LearningRate=1e-2,Momentum=0.9,ConvergenceSteps=20,BatchSize=100,TestRepetitions=1,WeightDecay=1e-4,Regularization=None,DropConfig=0.0+0.5+0.5+0.5:Architecture=CPU"
: The following options are set:
: - By User:
: <none>
: - Default:
: Boost_num: "0" [Number of times the classifier will be boosted]
: Parsing option string:
: ... "!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:Layout=TANH|128,TANH|128,TANH|128,LINEAR:TrainingStrategy=LearningRate=1e-2,Momentum=0.9,ConvergenceSteps=20,BatchSize=100,TestRepetitions=1,WeightDecay=1e-4,Regularization=None,DropConfig=0.0+0.5+0.5+0.5:Architecture=CPU"
: The following options are set:
: - By User:
: V: "True" [Verbose output (short form of "VerbosityLevel" below - overrides the latter one)]
: VarTransform: "N" [List of variable transformations performed before training, e.g., "D_Background,P_Signal,G,N_AllClasses" for: "Decorrelation, PCA-transformation, Gaussianisation, Normalisation, each for the given class of events ('AllClasses' denotes all events of all classes, if no class indication is given, 'All' is assumed)"]
: H: "False" [Print method-specific help message]
: Layout: "TANH|128,TANH|128,TANH|128,LINEAR" [Layout of the network.]
: ErrorStrategy: "CROSSENTROPY" [Loss function: Mean squared error (regression) or cross entropy (binary classification).]
: WeightInitialization: "XAVIERUNIFORM" [Weight initialization strategy]
: Architecture: "CPU" [Which architecture to perform the training on.]
: TrainingStrategy: "LearningRate=1e-2,Momentum=0.9,ConvergenceSteps=20,BatchSize=100,TestRepetitions=1,WeightDecay=1e-4,Regularization=None,DropConfig=0.0+0.5+0.5+0.5" [Defines the training strategies.]
: - Default:
: VerbosityLevel: "Default" [Verbosity level]
: CreateMVAPdfs: "False" [Create PDFs for classifier outputs (signal and background)]
: IgnoreNegWeightsInTraining: "False" [Events with negative weights are ignored in the training (but are included for testing and performance evaluation)]
: InputLayout: "0|0|0" [The Layout of the input]
: BatchLayout: "0|0|0" [The Layout of the batch]
: RandomSeed: "0" [Random seed used for weight initialization and batch shuffling]
: ValidationSize: "20%" [Part of the training data to use for validation. Specify as 0.2 or 20% to use a fifth of the data set as validation set. Specify as 100 to use exactly 100 events. (Default: 20%)]
DNN_CPU : [dataset] : Create Transformation "N" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
: Will now use the CPU architecture with BLAS and IMT support !
Factory : Booking method: SVM
:
SVM : [dataset] : Create Transformation "Norm" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
Factory : Booking method: BDT
:
Factory : Booking method: RuleFit
:
Factory : Train all methods
Factory : [dataset] : Create Transformation "I" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
Factory : [dataset] : Create Transformation "D" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
Factory : [dataset] : Create Transformation "P" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
Factory : [dataset] : Create Transformation "G" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
Factory : [dataset] : Create Transformation "D" with events from all classes.
:
: Transformation, Variable selection :
: Input : variable 'myvar1' <---> Output : variable 'myvar1'
: Input : variable 'myvar2' <---> Output : variable 'myvar2'
: Input : variable 'var3' <---> Output : variable 'var3'
: Input : variable 'var4' <---> Output : variable 'var4'
TFHandler_Factory : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.062775 1.7187 [ -9.3380 7.6931 ]
: myvar2: 0.056495 1.0784 [ -3.2551 4.0291 ]
: var3: -0.020366 1.0633 [ -5.2777 4.6430 ]
: var4: 0.13214 1.2464 [ -5.6007 4.6744 ]
: -----------------------------------------------------------
: Preparing the Decorrelation transformation...
TFHandler_Factory : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.17586 1.0000 [ -5.6401 4.8529 ]
: myvar2: 0.026952 1.0000 [ -2.9292 3.7065 ]
: var3: -0.11549 1.0000 [ -4.1792 3.5180 ]
: var4: 0.34819 1.0000 [ -3.3363 3.3963 ]
: -----------------------------------------------------------
: Preparing the Principle Component (PCA) transformation...
TFHandler_Factory : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.11433 2.2714 [ -11.272 9.0916 ]
: myvar2: -0.0070834 1.0934 [ -3.9875 3.3836 ]
: var3: 0.011107 0.57824 [ -2.0171 2.1958 ]
: var4: -0.0094450 0.33437 [ -1.0176 1.0617 ]
: -----------------------------------------------------------
: Preparing the Gaussian transformation...
: Preparing the Decorrelation transformation...
TFHandler_Factory : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.054412 1.0000 [ -3.0924 8.1350 ]
: myvar2: -0.0021417 1.0000 [ -4.5913 5.6461 ]
: var3: -0.0051998 1.0000 [ -3.1457 4.6043 ]
: var4: 0.074624 1.0000 [ -3.4587 5.9397 ]
: -----------------------------------------------------------
: Ranking input variables (method unspecific)...
IdTransformation : Ranking result (top variable is best ranked)
: -------------------------------------
: Rank : Variable : Separation
: -------------------------------------
: 1 : Variable 4 : 2.843e-01
: 2 : Variable 3 : 1.756e-01
: 3 : myvar1 : 1.018e-01
: 4 : Expression 2 : 3.860e-02
: -------------------------------------
Factory : Train method: Cuts for Classification
:
FitterBase : <MCFitter> Sampling, please be patient ...
: Elapsed time: 3.54 sec
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.1
: Corresponding background efficiency : 0.00621902
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -1.19223 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 2.126
: Cut[ 2]: -2.90978 < var3 <= 1e+30
: Cut[ 3]: 2.16207 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.2
: Corresponding background efficiency : 0.0171253
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -5.85714 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 2.21109
: Cut[ 2]: -0.759439 < var3 <= 1e+30
: Cut[ 3]: 1.66846 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.3
: Corresponding background efficiency : 0.0401486
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -6.09813 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 2.81831
: Cut[ 2]: -2.09336 < var3 <= 1e+30
: Cut[ 3]: 1.34308 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.4
: Corresponding background efficiency : 0.062887
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -4.55141 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 2.94573
: Cut[ 2]: -4.68697 < var3 <= 1e+30
: Cut[ 3]: 1.07157 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.5
: Corresponding background efficiency : 0.104486
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -5.86032 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 2.89615
: Cut[ 2]: -0.966191 < var3 <= 1e+30
: Cut[ 3]: 0.773848 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.6
: Corresponding background efficiency : 0.172806
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -5.52552 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 4.08498
: Cut[ 2]: -2.61706 < var3 <= 1e+30
: Cut[ 3]: 0.469684 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.7
: Corresponding background efficiency : 0.258379
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -5.69875 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 1.73784
: Cut[ 2]: -1.21467 < var3 <= 1e+30
: Cut[ 3]: 0.109026 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.8
: Corresponding background efficiency : 0.362964
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -1.99372 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 3.93767
: Cut[ 2]: -1.56317 < var3 <= 1e+30
: Cut[ 3]: -0.124013 < var4 <= 1e+30
: ------------------------------------------
: ------------------------------------------
Cuts : Cut values for requested signal efficiency: 0.9
: Corresponding background efficiency : 0.503885
: Transformation applied to input variables : None
: ------------------------------------------
: Cut[ 0]: -3.97304 < myvar1 <= 1e+30
: Cut[ 1]: -1e+30 < myvar2 <= 3.31284
: Cut[ 2]: -2.82879 < var3 <= 1e+30
: Cut[ 3]: -0.577302 < var4 <= 1e+30
: ------------------------------------------
: Elapsed time for training with 2000 events: 3.54 sec
Cuts : [dataset] : Evaluation of Cuts on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.000283 sec
: Creating xml weight file: dataset/weights/TMVAClassification_Cuts.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_Cuts.class.C
: TMVA.root:/dataset/Method_Cuts/Cuts
Factory : Training finished
:
Factory : Train method: CutsD for Classification
:
: Preparing the Decorrelation transformation...
TFHandler_CutsD : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.17586 1.0000 [ -5.6401 4.8529 ]
: myvar2: 0.026952 1.0000 [ -2.9292 3.7065 ]
: var3: -0.11549 1.0000 [ -4.1792 3.5180 ]
: var4: 0.34819 1.0000 [ -3.3363 3.3963 ]
: -----------------------------------------------------------
TFHandler_CutsD : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.17586 1.0000 [ -5.6401 4.8529 ]
: myvar2: 0.026952 1.0000 [ -2.9292 3.7065 ]
: var3: -0.11549 1.0000 [ -4.1792 3.5180 ]
: var4: 0.34819 1.0000 [ -3.3363 3.3963 ]
: -----------------------------------------------------------
FitterBase : <MCFitter> Sampling, please be patient ...
: Elapsed time: 2.83 sec
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.1
: Corresponding background efficiency : 0
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 0.513038
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= -0.733858
: Cut[ 2]: -0.87113 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 0.687739 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.2
: Corresponding background efficiency : 0.000493656
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 1.60056
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 1.26936
: Cut[ 2]: -1.50073 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 1.54845 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.3
: Corresponding background efficiency : 0.00334252
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 2.16898
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 3.25932
: Cut[ 2]: -2.08503 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 1.43959 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.4
: Corresponding background efficiency : 0.00821453
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 1.9086
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 1.94778
: Cut[ 2]: -2.11471 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 1.1885 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.5
: Corresponding background efficiency : 0.0209024
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 3.97301
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 2.87835
: Cut[ 2]: -1.68889 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 0.969507 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.6
: Corresponding background efficiency : 0.055037
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 2.57624
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 2.20263
: Cut[ 2]: -3.86902 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 0.802122 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.7
: Corresponding background efficiency : 0.0975699
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 3.65719
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 3.19411
: Cut[ 2]: -2.87372 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 0.583961 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.8
: Corresponding background efficiency : 0.170999
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 4.74857
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 2.75269
: Cut[ 2]: -3.22043 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 0.327788 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: ------------------------------------------------------------------------------------------------------------------------
CutsD : Cut values for requested signal efficiency: 0.9
: Corresponding background efficiency : 0.326977
: Transformation applied to input variables : "Deco"
: ------------------------------------------------------------------------------------------------------------------------
: Cut[ 0]: -1e+30 < + 1.1476*[myvar1] + 0.027923*[myvar2] - 0.19981*[var3] - 0.82843*[var4] <= 3.56614
: Cut[ 1]: -1e+30 < + 0.027923*[myvar1] + 0.95469*[myvar2] + 0.18581*[var3] - 0.1623*[var4] <= 3.09071
: Cut[ 2]: -3.9944 < - 0.19981*[myvar1] + 0.18581*[myvar2] + 1.7913*[var3] - 0.77231*[var4] <= 1e+30
: Cut[ 3]: 0.0311777 < - 0.82843*[myvar1] - 0.1623*[myvar2] - 0.77231*[var3] + 2.1918*[var4] <= 1e+30
: ------------------------------------------------------------------------------------------------------------------------
: Elapsed time for training with 2000 events: 2.83 sec
CutsD : [dataset] : Evaluation of CutsD on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.00187 sec
: Creating xml weight file: dataset/weights/TMVAClassification_CutsD.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_CutsD.class.C
: TMVA.root:/dataset/Method_Cuts/CutsD
Factory : Training finished
:
Factory : Train method: Likelihood for Classification
:
:
: ================================================================
: H e l p f o r M V A m e t h o d [ Likelihood ] :
:
: --- Short description:
:
: The maximum-likelihood classifier models the data with probability
: density functions (PDF) reproducing the signal and background
: distributions of the input variables. Correlations among the
: variables are ignored.
:
: --- Performance optimisation:
:
: Required for good performance are decorrelated input variables
: (PCA transformation via the option "VarTransform=Decorrelate"
: may be tried). Irreducible non-linear correlations may be reduced
: by precombining strongly correlated input variables, or by simply
: removing one of the variables.
:
: --- Performance tuning via configuration options:
:
: High fidelity PDF estimates are mandatory, i.e., sufficient training
: statistics is required to populate the tails of the distributions
: It would be a surprise if the default Spline or KDE kernel parameters
: provide a satisfying fit to the data. The user is advised to properly
: tune the events per bin and smooth options in the spline cases
: individually per variable. If the KDE kernel is used, the adaptive
: Gaussian kernel may lead to artefacts, so please always also try
: the non-adaptive one.
:
: All tuning parameters must be adjusted individually for each input
: variable!
:
: <Suppress this message by specifying "!H" in the booking option>
: ================================================================
:
: Filling reference histograms
: Building PDF out of reference histograms
: Elapsed time for training with 2000 events: 0.0145 sec
Likelihood : [dataset] : Evaluation of Likelihood on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.00276 sec
: Creating xml weight file: dataset/weights/TMVAClassification_Likelihood.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_Likelihood.class.C
: TMVA.root:/dataset/Method_Likelihood/Likelihood
Factory : Training finished
:
Factory : Train method: LikelihoodPCA for Classification
:
: Preparing the Principle Component (PCA) transformation...
TFHandler_LikelihoodPCA : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.11433 2.2714 [ -11.272 9.0916 ]
: myvar2: -0.0070834 1.0934 [ -3.9875 3.3836 ]
: var3: 0.011107 0.57824 [ -2.0171 2.1958 ]
: var4: -0.0094450 0.33437 [ -1.0176 1.0617 ]
: -----------------------------------------------------------
: Filling reference histograms
: Building PDF out of reference histograms
: Elapsed time for training with 2000 events: 0.0171 sec
LikelihoodPCA : [dataset] : Evaluation of LikelihoodPCA on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.00432 sec
: Creating xml weight file: dataset/weights/TMVAClassification_LikelihoodPCA.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_LikelihoodPCA.class.C
: TMVA.root:/dataset/Method_Likelihood/LikelihoodPCA
Factory : Training finished
:
Factory : Train method: PDERS for Classification
:
: Elapsed time for training with 2000 events: 0.00353 sec
PDERS : [dataset] : Evaluation of PDERS on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.264 sec
: Creating xml weight file: dataset/weights/TMVAClassification_PDERS.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_PDERS.class.C
Factory : Training finished
:
Factory : Train method: PDEFoam for Classification
:
PDEFoam : NormMode=NUMEVENTS chosen. Note that only NormMode=EqualNumEvents ensures that Discriminant values correspond to signal probabilities.
: Build up discriminator foam
: Elapsed time: 0.338 sec
: Elapsed time for training with 2000 events: 0.367 sec
PDEFoam : [dataset] : Evaluation of PDEFoam on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.0141 sec
: Creating xml weight file: dataset/weights/TMVAClassification_PDEFoam.weights.xml
: writing foam DiscrFoam to file
: Foams written to file: dataset/weights/TMVAClassification_PDEFoam.weights_foams.root
: Creating standalone class: dataset/weights/TMVAClassification_PDEFoam.class.C
Factory : Training finished
:
Factory : Train method: KNN for Classification
:
:
: ================================================================
: H e l p f o r M V A m e t h o d [ KNN ] :
:
: --- Short description:
:
: The k-nearest neighbor (k-NN) algorithm is a multi-dimensional classification
: and regression algorithm. Similarly to other TMVA algorithms, k-NN uses a set of
: training events for which a classification category/regression target is known.
: The k-NN method compares a test event to all training events using a distance
: function, which is an Euclidean distance in a space defined by the input variables.
: The k-NN method, as implemented in TMVA, uses a kd-tree algorithm to perform a
: quick search for the k events with shortest distance to the test event. The method
: returns a fraction of signal events among the k neighbors. It is recommended
: that a histogram which stores the k-NN decision variable is binned with k+1 bins
: between 0 and 1.
:
: --- Performance tuning via configuration options: 
:
: The k-NN method estimates a density of signal and background events in a
: neighborhood around the test event. The method assumes that the density of the
: signal and background events is uniform and constant within the neighborhood.
: k is an adjustable parameter and it determines an average size of the
: neighborhood. Small k values (less than 10) are sensitive to statistical
: fluctuations and large (greater than 100) values might not sufficiently capture
: local differences between events in the training set. The speed of the k-NN
: method also increases with larger values of k.
:
: The k-NN method assigns equal weight to all input variables. Different scales
: among the input variables is compensated using ScaleFrac parameter: the input
: variables are scaled so that the widths for central ScaleFrac*100% events are
: equal among all the input variables.
:
: --- Additional configuration options: 
:
: The method inclues an option to use a Gaussian kernel to smooth out the k-NN
: response. The kernel re-weights events using a distance to the test event.
:
: <Suppress this message by specifying "!H" in the booking option>
: ================================================================
:
KNN : <Train> start...
: Reading 2000 events
: Number of signal events 1000
: Number of background events 1000
: Creating kd-tree with 2000 events
: Computing scale factor for 1d distributions: (ifrac, bottom, top) = (80%, 10%, 90%)
ModulekNN : Optimizing tree for 4 variables with 2000 values
: <Fill> Class 1 has 1000 events
: <Fill> Class 2 has 1000 events
: Elapsed time for training with 2000 events: 0.00294 sec
KNN : [dataset] : Evaluation of KNN on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.0393 sec
: Creating xml weight file: dataset/weights/TMVAClassification_KNN.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_KNN.class.C
Factory : Training finished
:
Factory : Train method: LD for Classification
:
:
: ================================================================
: H e l p f o r M V A m e t h o d [ LD ] :
:
: --- Short description:
:
: Linear discriminants select events by distinguishing the mean
: values of the signal and background distributions in a trans-
: formed variable space where linear correlations are removed.
: The LD implementation here is equivalent to the "Fisher" discriminant
: for classification, but also provides linear regression.
:
: (More precisely: the "linear discriminator" determines
: an axis in the (correlated) hyperspace of the input
: variables such that, when projecting the output classes
: (signal and background) upon this axis, they are pushed
: as far as possible away from each other, while events
: of a same class are confined in a close vicinity. The
: linearity property of this classifier is reflected in the
: metric with which "far apart" and "close vicinity" are
: determined: the covariance matrix of the discriminating
: variable space.)
:
: --- Performance optimisation:
:
: Optimal performance for the linear discriminant is obtained for
: linearly correlated Gaussian-distributed variables. Any deviation
: from this ideal reduces the achievable separation power. In
: particular, no discrimination at all is achieved for a variable
: that has the same sample mean for signal and background, even if
: the shapes of the distributions are very different. Thus, the linear
: discriminant often benefits from a suitable transformation of the
: input variables. For example, if a variable x in [-1,1] has a
: a parabolic signal distributions, and a uniform background
: distributions, their mean value is zero in both cases, leading
: to no separation. The simple transformation x -> |x| renders this
: variable powerful for the use in a linear discriminant.
:
: --- Performance tuning via configuration options:
:
: <None>
:
: <Suppress this message by specifying "!H" in the booking option>
: ================================================================
:
LD : Results for LD coefficients:
: -----------------------
: Variable: Coefficient:
: -----------------------
: myvar1: -0.309
: myvar2: -0.102
: var3: -0.142
: var4: +0.705
: (offset): -0.055
: -----------------------
: Elapsed time for training with 2000 events: 0.00105 sec
LD : [dataset] : Evaluation of LD on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.000431 sec
: <CreateMVAPdfs> Separation from histogram (PDF): 0.540 (0.000)
: Dataset[dataset] : Evaluation of LD on training sample
: Creating xml weight file: dataset/weights/TMVAClassification_LD.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_LD.class.C
Factory : Training finished
:
Factory : Train method: FDA_GA for Classification
:
:
: ================================================================
: H e l p f o r M V A m e t h o d [ FDA_GA ] :
:
: --- Short description:
:
: The function discriminant analysis (FDA) is a classifier suitable
: to solve linear or simple nonlinear discrimination problems.
:
: The user provides the desired function with adjustable parameters
: via the configuration option string, and FDA fits the parameters to
: it, requiring the signal (background) function value to be as close
: as possible to 1 (0). Its advantage over the more involved and
: automatic nonlinear discriminators is the simplicity and transparency
: of the discrimination expression. A shortcoming is that FDA will
: underperform for involved problems with complicated, phase space
: dependent nonlinear correlations.
:
: Please consult the Users Guide for the format of the formula string
: and the allowed parameter ranges:
: http://tmva.sourceforge.net/docu/TMVAUsersGuide.pdf
:
: --- Performance optimisation:
:
: The FDA performance depends on the complexity and fidelity of the
: user-defined discriminator function. As a general rule, it should
: be able to reproduce the discrimination power of any linear
: discriminant analysis. To reach into the nonlinear domain, it is
: useful to inspect the correlation profiles of the input variables,
: and add quadratic and higher polynomial terms between variables as
: necessary. Comparison with more involved nonlinear classifiers can
: be used as a guide.
:
: --- Performance tuning via configuration options:
:
: Depending on the function used, the choice of "FitMethod" is
: crucial for getting valuable solutions with FDA. As a guideline it
: is recommended to start with "FitMethod=MINUIT". When more complex
: functions are used where MINUIT does not converge to reasonable
: results, the user should switch to non-gradient FitMethods such
: as GeneticAlgorithm (GA) or Monte Carlo (MC). It might prove to be
: useful to combine GA (or MC) with MINUIT by setting the option
: "Converger=MINUIT". GA (MC) will then set the starting parameters
: for MINUIT such that the basic quality of GA (MC) of finding global
: minima is combined with the efficacy of MINUIT of finding local
: minima.
:
: <Suppress this message by specifying "!H" in the booking option>
: ================================================================
:
FitterBase : <GeneticFitter> Optimisation, please be patient ... (inaccurate progress timing for GA)
: Elapsed time: 0.567 sec
FDA_GA : Results for parameter fit using "GA" fitter:
: -----------------------
: Parameter: Fit result:
: -----------------------
: Par(0): 0.516172
: Par(1): 0
: Par(2): 0
: Par(3): 0
: Par(4): 0
: -----------------------
: Discriminator expression: "(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3"
: Value of estimator at minimum: 0.500523
: Elapsed time for training with 2000 events: 0.597 sec
FDA_GA : [dataset] : Evaluation of FDA_GA on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.000424 sec
: Creating xml weight file: dataset/weights/TMVAClassification_FDA_GA.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_FDA_GA.class.C
Factory : Training finished
:
Factory : Train method: MLPBNN for Classification
:
:
: ================================================================
: H e l p f o r M V A m e t h o d [ MLPBNN ] :
:
: --- Short description:
:
: The MLP artificial neural network (ANN) is a traditional feed-
: forward multilayer perceptron implementation. The MLP has a user-
: defined hidden layer architecture, while the number of input (output)
: nodes is determined by the input variables (output classes, i.e.,
: signal and one background).
:
: --- Performance optimisation:
:
: Neural networks are stable and performing for a large variety of
: linear and non-linear classification problems. However, in contrast
: to (e.g.) boosted decision trees, the user is advised to reduce the
: number of input variables that have only little discrimination power.
:
: In the tests we have carried out so far, the MLP and ROOT networks
: (TMlpANN, interfaced via TMVA) performed equally well, with however
: a clear speed advantage for the MLP. The Clermont-Ferrand neural
: net (CFMlpANN) exhibited worse classification performance in these
: tests, which is partly due to the slow convergence of its training
: (at least 10k training cycles are required to achieve approximately
: competitive results).
:
: Overtraining: only the TMlpANN performs an explicit separation of the
: full training sample into independent training and validation samples.
: We have found that in most high-energy physics applications the
: available degrees of freedom (training events) are sufficient to
: constrain the weights of the relatively simple architectures required
: to achieve good performance. Hence no overtraining should occur, and
: the use of validation samples would only reduce the available training
: information. However, if the performance on the training sample is
: found to be significantly better than the one found with the inde-
: pendent test sample, caution is needed. The results for these samples
: are printed to standard output at the end of each training job.
:
: --- Performance tuning via configuration options:
:
: The hidden layer architecture for all ANNs is defined by the option
: "HiddenLayers=N+1,N,...", where here the first hidden layer has N+1
: neurons and the second N neurons (and so on), and where N is the number
: of input variables. Excessive numbers of hidden layers should be avoided,
: in favour of more neurons in the first hidden layer.
:
: The number of cycles should be above 500. As said, if the number of
: adjustable weights is small compared to the training sample size,
: using a large number of training samples should not lead to overtraining.
:
: <Suppress this message by specifying "!H" in the booking option>
: ================================================================
:
TFHandler_MLPBNN : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.089214 0.20183 [ -1.0000 1.0000 ]
: myvar2: -0.090751 0.29609 [ -1.0000 1.0000 ]
: var3: 0.059878 0.21436 [ -1.0000 1.0000 ]
: var4: 0.11587 0.24261 [ -1.0000 1.0000 ]
: -----------------------------------------------------------
: Training Network
:
: Finalizing handling of Regulator terms, trainE=0.713219 testE=0.724617
: Done with handling of Regulator terms
: Elapsed time for training with 2000 events: 2.47 sec
MLPBNN : [dataset] : Evaluation of MLPBNN on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.00314 sec
: Creating xml weight file: dataset/weights/TMVAClassification_MLPBNN.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_MLPBNN.class.C
: Write special histos to file: TMVA.root:/dataset/Method_MLP/MLPBNN
Factory : Training finished
:
Factory : Train method: DNN_CPU for Classification
:
TFHandler_DNN_CPU : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.089214 0.20183 [ -1.0000 1.0000 ]
: myvar2: -0.090751 0.29609 [ -1.0000 1.0000 ]
: var3: 0.059878 0.21436 [ -1.0000 1.0000 ]
: var4: 0.11587 0.24261 [ -1.0000 1.0000 ]
: -----------------------------------------------------------
: Start of deep neural network training on CPU using MT, nthreads = 1
:
TFHandler_DNN_CPU : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.089214 0.20183 [ -1.0000 1.0000 ]
: myvar2: -0.090751 0.29609 [ -1.0000 1.0000 ]
: var3: 0.059878 0.21436 [ -1.0000 1.0000 ]
: var4: 0.11587 0.24261 [ -1.0000 1.0000 ]
: -----------------------------------------------------------
: ***** Deep Learning Network *****
DEEP NEURAL NETWORK: Depth = 4 Input = ( 1, 1, 4 ) Batch size = 100 Loss function = C
Layer 0 DENSE Layer: ( Input = 4 , Width = 128 ) Output = ( 1 , 100 , 128 ) Activation Function = Tanh
Layer 1 DENSE Layer: ( Input = 128 , Width = 128 ) Output = ( 1 , 100 , 128 ) Activation Function = Tanh Dropout prob. = 0.5
Layer 2 DENSE Layer: ( Input = 128 , Width = 128 ) Output = ( 1 , 100 , 128 ) Activation Function = Tanh Dropout prob. = 0.5
Layer 3 DENSE Layer: ( Input = 128 , Width = 1 ) Output = ( 1 , 100 , 1 ) Activation Function = Identity Dropout prob. = 0.5
: Using 1600 events for training and 400 for testing
: Compute initial loss on the validation data
: Training phase 1 of 1: Optimizer ADAM Learning rate = 0.01 regularization 0 minimum error = 0.713891
: --------------------------------------------------------------
: Epoch | Train Err. Val. Err. t(s)/epoch t(s)/Loss nEvents/s Conv. Steps
: --------------------------------------------------------------
: Start epoch iteration ...
: 1 Minimum Test error found - save the configuration
: 1 | 0.546875 0.497496 0.192492 0.014824 9005.55 0
: 2 Minimum Test error found - save the configuration
: 2 | 0.443829 0.381214 0.193958 0.0147157 8926.47 0
: 3 | 0.393259 0.401063 0.193422 0.0143789 8936.4 1
: 4 | 0.400922 0.404859 0.1938 0.0143843 8917.82 2
: 5 | 0.399672 0.397416 0.194406 0.014449 8891 3
: 6 | 0.411616 0.410374 0.194366 0.0143947 8890.29 4
: 7 | 0.411591 0.396365 0.193974 0.0143997 8909.96 5
: 8 | 0.401853 0.398206 0.193912 0.0143083 8908.48 6
: 9 | 0.419554 0.386316 0.194337 0.0143731 8890.68 7
: 10 | 0.394122 0.383614 0.194154 0.0143755 8899.83 8
: 11 | 0.402775 0.404238 0.19447 0.0144217 8886.49 9
: 12 | 0.399235 0.397115 0.194574 0.0144211 8881.33 10
: 13 | 0.413377 0.395773 0.194965 0.0144856 8865.3 11
: 14 | 0.391425 0.387201 0.195133 0.0144919 8857.33 12
: 15 | 0.395656 0.402261 0.194675 0.0145152 8880.99 13
: 16 Minimum Test error found - save the configuration
: 16 | 0.383756 0.376564 0.194918 0.0147869 8882.4 0
: 17 | 0.384084 0.406551 0.194404 0.0144262 8889.96 1
: 18 | 0.404551 0.387771 0.194495 0.0143896 8883.7 2
: 19 | 0.393804 0.38319 0.194573 0.0145006 8885.32 3
: 20 | 0.39553 0.376708 0.194456 0.0144358 8887.91 4
: 21 | 0.386665 0.418545 0.194848 0.0144833 8870.89 5
: 22 | 0.395507 0.402768 0.195636 0.0145623 8836.19 6
: 23 | 0.391059 0.381057 0.195495 0.0145346 8841.7 7
: 24 Minimum Test error found - save the configuration
: 24 | 0.382859 0.375909 0.195319 0.0148929 8867.9 0
: 25 | 0.40088 0.379639 0.195923 0.0146685 8827.37 1
: 26 Minimum Test error found - save the configuration
: 26 | 0.397247 0.374385 0.195971 0.0148981 8836.23 0
: 27 | 0.381882 0.387213 0.195439 0.0146032 8847.79 1
: 28 | 0.384993 0.388916 0.197635 0.0146356 8743.19 2
: 29 | 0.392962 0.411343 0.195754 0.0145619 8830.4 3
: 30 | 0.419749 0.421376 0.195731 0.0145262 8829.79 4
: 31 | 0.390902 0.377936 0.195377 0.0145252 8847.01 5
: 32 | 0.372826 0.375125 0.196401 0.0145367 8797.75 6
: 33 | 0.39717 0.380909 0.196098 0.0145683 8813.99 7
: 34 Minimum Test error found - save the configuration
: 34 | 0.395429 0.370959 0.196671 0.0149272 8803.59 0
: 35 | 0.39186 0.381447 0.195842 0.0146323 8829.55 1
: 36 | 0.393746 0.386027 0.195767 0.0146162 8832.43 2
: 37 | 0.397506 0.375009 0.196289 0.0146642 8809.38 3
: 38 | 0.390696 0.387011 0.195864 0.0145225 8823.15 4
: 39 | 0.399316 0.37385 0.196372 0.0152947 8836.01 5
: 40 | 0.400584 0.393307 0.197189 0.0145388 8759.92 6
: 41 | 0.412657 0.418816 0.196029 0.0145731 8817.57 7
: 42 | 0.414013 0.377445 0.195764 0.0146133 8832.44 8
: 43 | 0.404836 0.392229 0.196242 0.014589 8807.98 9
: 44 | 0.437962 0.382339 0.195792 0.0147212 8836.3 10
: 45 | 0.402117 0.418075 0.195886 0.0146173 8826.69 11
: 46 | 0.397891 0.380392 0.195812 0.0146368 8831.25 12
: 47 | 0.392484 0.422952 0.196506 0.0147171 8801.4 13
: 48 | 0.42629 0.418335 0.196523 0.0147125 8800.35 14
: 49 | 0.410438 0.378395 0.196367 0.0147594 8810.19 15
: 50 | 0.383089 0.374234 0.19701 0.0147394 8778.17 16
: 51 | 0.399126 0.391746 0.196607 0.014672 8794.33 17
: 52 | 0.389146 0.398796 0.196252 0.0146833 8812.1 18
: 53 | 0.40555 0.383122 0.199022 0.014769 8683.72 19
: 54 | 0.399958 0.379934 0.196842 0.0147191 8785.29 20
: 55 | 0.396813 0.38309 0.196943 0.01475 8781.88 21
:
: Elapsed time for training with 2000 events: 10.8 sec
: Evaluate deep neural network on CPU using batches with size = 100
:
DNN_CPU : [dataset] : Evaluation of DNN_CPU on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.0734 sec
: Creating xml weight file: dataset/weights/TMVAClassification_DNN_CPU.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_DNN_CPU.class.C
Factory : Training finished
:
Factory : Train method: SVM for Classification
:
TFHandler_SVM : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.089214 0.20183 [ -1.0000 1.0000 ]
: myvar2: -0.090751 0.29609 [ -1.0000 1.0000 ]
: var3: 0.059878 0.21436 [ -1.0000 1.0000 ]
: var4: 0.11587 0.24261 [ -1.0000 1.0000 ]
: -----------------------------------------------------------
: Building SVM Working Set...with 2000 event instances
: Elapsed time for Working Set build: 0.0957 sec
: Sorry, no computing time forecast available for SVM, please wait ...
: Elapsed time: 0.344 sec
: Elapsed time for training with 2000 events: 0.444 sec
SVM : [dataset] : Evaluation of SVM on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.0636 sec
: Creating xml weight file: dataset/weights/TMVAClassification_SVM.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_SVM.class.C
Factory : Training finished
:
Factory : Train method: BDT for Classification
:
BDT : #events: (reweighted) sig: 1000 bkg: 1000
: #events: (unweighted) sig: 1000 bkg: 1000
: Training 850 Decision Trees ... patience please
: Elapsed time for training with 2000 events: 0.624 sec
BDT : [dataset] : Evaluation of BDT on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.148 sec
: Creating xml weight file: dataset/weights/TMVAClassification_BDT.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_BDT.class.C
: TMVA.root:/dataset/Method_BDT/BDT
Factory : Training finished
:
Factory : Train method: RuleFit for Classification
:
:
: ================================================================
: H e l p f o r M V A m e t h o d [ RuleFit ] :
:
: --- Short description:
:
: This method uses a collection of so called rules to create a
: discriminating scoring function. Each rule consists of a series
: of cuts in parameter space. The ensemble of rules are created
: from a forest of decision trees, trained using the training data.
: Each node (apart from the root) corresponds to one rule.
: The scoring function is then obtained by linearly combining
: the rules. A fitting procedure is applied to find the optimum
: set of coefficients. The goal is to find a model with few rules
: but with a strong discriminating power.
:
: --- Performance optimisation:
:
: There are two important considerations to make when optimising:
:
: 1. Topology of the decision tree forest
: 2. Fitting of the coefficients
:
: The maximum complexity of the rules is defined by the size of
: the trees. Large trees will yield many complex rules and capture
: higher order correlations. On the other hand, small trees will
: lead to a smaller ensemble with simple rules, only capable of
: modeling simple structures.
: Several parameters exists for controlling the complexity of the
: rule ensemble.
:
: The fitting procedure searches for a minimum using a gradient
: directed path. Apart from step size and number of steps, the
: evolution of the path is defined by a cut-off parameter, tau.
: This parameter is unknown and depends on the training data.
: A large value will tend to give large weights to a few rules.
: Similarly, a small value will lead to a large set of rules
: with similar weights.
:
: A final point is the model used; rules and/or linear terms.
: For a given training sample, the result may improve by adding
: linear terms. If best performance is obtained using only linear
: terms, it is very likely that the Fisher discriminant would be
: a better choice. Ideally the fitting procedure should be able to
: make this choice by giving appropriate weights for either terms.
:
: --- Performance tuning via configuration options:
:
: I. TUNING OF RULE ENSEMBLE:
:
: ForestType : Recommended is to use the default "AdaBoost".
: nTrees : More trees leads to more rules but also slow
: performance. With too few trees the risk is
: that the rule ensemble becomes too simple.
: fEventsMin 
: fEventsMax : With a lower min, more large trees will be generated
: leading to more complex rules.
: With a higher max, more small trees will be
: generated leading to more simple rules.
: By changing this range, the average complexity
: of the rule ensemble can be controlled.
: RuleMinDist : By increasing the minimum distance between
: rules, fewer and more diverse rules will remain.
: Initially it is a good idea to keep this small
: or zero and let the fitting do the selection of
: rules. In order to reduce the ensemble size,
: the value can then be increased.
:
: II. TUNING OF THE FITTING:
:
: GDPathEveFrac : fraction of events in path evaluation
: Increasing this fraction will improve the path
: finding. However, a too high value will give few
: unique events available for error estimation.
: It is recommended to use the default = 0.5.
: GDTau : cutoff parameter tau
: By default this value is set to -1.0.
: This means that the cut off parameter is
: automatically estimated. In most cases
: this should be fine. However, you may want
: to fix this value if you already know it
: and want to reduce on training time.
: GDTauPrec : precision of estimated tau
: Increase this precision to find a more
: optimum cut-off parameter.
: GDNStep : number of steps in path search
: If the number of steps is too small, then
: the program will give a warning message.
:
: III. WARNING MESSAGES
:
: Risk(i+1)>=Risk(i) in path
: Chaotic behaviour of risk evolution.
: The error rate was still decreasing at the end
: By construction the Risk should always decrease.
: However, if the training sample is too small or
: the model is overtrained, such warnings can
: occur.
: The warnings can safely be ignored if only a
: few (<3) occur. If more warnings are generated,
: the fitting fails.
: A remedy may be to increase the value
: GDValidEveFrac to 1.0 (or a larger value).
: In addition, if GDPathEveFrac is too high
: the same warnings may occur since the events
: used for error estimation are also used for
: path estimation.
: Another possibility is to modify the model -
: See above on tuning the rule ensemble.
:
: The error rate was still decreasing at the end of the path
: Too few steps in path! Increase GDNSteps.
:
: Reached minimum early in the search
: Minimum was found early in the fitting. This
: may indicate that the used step size GDStep.
: was too large. Reduce it and rerun.
: If the results still are not OK, modify the
: model either by modifying the rule ensemble
: or add/remove linear terms
:
: <Suppress this message by specifying "!H" in the booking option>
: ================================================================
:
RuleFit : -------------------RULE ENSEMBLE SUMMARY------------------------
: Tree training method : AdaBoost
: Number of events per tree : 2000
: Number of trees : 20
: Number of generated rules : 196
: Idem, after cleanup : 80
: Average number of cuts per rule : 3.01
: Spread in number of cuts per rules : 1.23
: ----------------------------------------------------------------
:
: GD path scan - the scan stops when the max num. of steps is reached or a min is found
: Estimating the cutoff parameter tau. The estimated time is a pessimistic maximum.
: Best path found with tau = 0.0000 after 2.22 sec
: Fitting model...
<WARNING> :
: Minimisation elapsed time : 1.25 sec
: ----------------------------------------------------------------
: Found minimum at step 10000 with error = 0.552378
: Reason for ending loop: end of loop reached
: ----------------------------------------------------------------
: The error rate was still decreasing at the end of the path
: Increase number of steps (GDNSteps).
: Removed 28 out of a total of 80 rules with importance < 0.001
:
: ================================================================
: M o d e l
: ================================================================
RuleFit : Offset (a0) = 9.46803
: ------------------------------------
: Linear model (weights unnormalised)
: ------------------------------------
: Variable : Weights : Importance
: ------------------------------------
: myvar1 : -6.338e-01 : 0.472
: myvar2 : -4.488e-01 : 0.209
: var3 : -2.810e-01 : 0.129
: var4 : 1.850e+00 : 1.000
: ------------------------------------
: Number of rules = 52
: Printing the first 10 rules, ordered in importance.
: Rule 1 : Importance = 0.4294
: Cut 1 : -0.708 < var4
: Rule 2 : Importance = 0.3676
: Cut 1 : var3 < -0.0812
: Rule 3 : Importance = 0.3363
: Cut 1 : -0.0812 < var3
: Rule 4 : Importance = 0.2934
: Cut 1 : -0.877 < var3
: Cut 2 : 0.271 < var4
: Rule 5 : Importance = 0.2706
: Cut 1 : myvar1 < 2.83
: Cut 2 : -1.67 < var3
: Rule 6 : Importance = 0.2387
: Cut 1 : myvar1 < 1.46
: Cut 2 : var4 < 0.271
: Rule 7 : Importance = 0.1904
: Cut 1 : var4 < -0.708
: Rule 8 : Importance = 0.1897
: Cut 1 : var3 < 0.256
: Cut 2 : var4 < -0.708
: Rule 9 : Importance = 0.1689
: Cut 1 : myvar1 < -2.85
: Rule 10 : Importance = 0.1611
: Cut 1 : -2.85 < myvar1 < 2.68
: Skipping the next 42 rules
: ================================================================
:
<WARNING> : No input variable directory found - BUG?
: Elapsed time for training with 2000 events: 3.51 sec
RuleFit : [dataset] : Evaluation of RuleFit on training sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.00235 sec
: Creating xml weight file: dataset/weights/TMVAClassification_RuleFit.weights.xml
: Creating standalone class: dataset/weights/TMVAClassification_RuleFit.class.C
: TMVA.root:/dataset/Method_RuleFit/RuleFit
Factory : Training finished
:
: Ranking input variables (method specific)...
: No variable ranking supplied by classifier: Cuts
: No variable ranking supplied by classifier: CutsD
Likelihood : Ranking result (top variable is best ranked)
: -------------------------------------
: Rank : Variable : Delta Separation
: -------------------------------------
: 1 : var4 : 5.365e-02
: 2 : myvar1 : -4.483e-04
: 3 : myvar2 : -2.298e-03
: 4 : var3 : -9.266e-03
: -------------------------------------
LikelihoodPCA : Ranking result (top variable is best ranked)
: -------------------------------------
: Rank : Variable : Delta Separation
: -------------------------------------
: 1 : var4 : 2.952e-01
: 2 : myvar1 : 7.646e-02
: 3 : var3 : 2.035e-02
: 4 : myvar2 : 1.950e-02
: -------------------------------------
: No variable ranking supplied by classifier: PDERS
PDEFoam : Ranking result (top variable is best ranked)
: ----------------------------------------
: Rank : Variable : Variable Importance
: ----------------------------------------
: 1 : var4 : 3.830e-01
: 2 : myvar1 : 2.979e-01
: 3 : var3 : 1.915e-01
: 4 : myvar2 : 1.277e-01
: ----------------------------------------
: No variable ranking supplied by classifier: KNN
LD : Ranking result (top variable is best ranked)
: ---------------------------------
: Rank : Variable : Discr. power
: ---------------------------------
: 1 : var4 : 7.053e-01
: 2 : myvar1 : 3.094e-01
: 3 : var3 : 1.423e-01
: 4 : myvar2 : 1.019e-01
: ---------------------------------
: No variable ranking supplied by classifier: FDA_GA
MLPBNN : Ranking result (top variable is best ranked)
: -------------------------------
: Rank : Variable : Importance
: -------------------------------
: 1 : var4 : 1.360e+00
: 2 : myvar2 : 1.009e+00
: 3 : myvar1 : 8.834e-01
: 4 : var3 : 3.562e-01
: -------------------------------
: No variable ranking supplied by classifier: DNN_CPU
: No variable ranking supplied by classifier: SVM
BDT : Ranking result (top variable is best ranked)
: ----------------------------------------
: Rank : Variable : Variable Importance
: ----------------------------------------
: 1 : var4 : 2.697e-01
: 2 : myvar1 : 2.467e-01
: 3 : myvar2 : 2.460e-01
: 4 : var3 : 2.377e-01
: ----------------------------------------
RuleFit : Ranking result (top variable is best ranked)
: -------------------------------
: Rank : Variable : Importance
: -------------------------------
: 1 : var4 : 1.000e+00
: 2 : myvar1 : 6.981e-01
: 3 : var3 : 5.947e-01
: 4 : myvar2 : 4.105e-01
: -------------------------------
TH1.Print Name = TrainingHistory_DNN_CPU_trainingError, Entries= 0, Total sum= 22.1237
TH1.Print Name = TrainingHistory_DNN_CPU_valError, Entries= 0, Total sum= 21.6169
Factory : === Destroy and recreate all methods via weight files for testing ===
:
: Reading weight file: dataset/weights/TMVAClassification_Cuts.weights.xml
: Read cuts optimised using sample of MC events
: Reading 100 signal efficiency bins for 4 variables
: Reading weight file: dataset/weights/TMVAClassification_CutsD.weights.xml
: Read cuts optimised using sample of MC events
: Reading 100 signal efficiency bins for 4 variables
: Reading weight file: dataset/weights/TMVAClassification_Likelihood.weights.xml
: Reading weight file: dataset/weights/TMVAClassification_LikelihoodPCA.weights.xml
: Reading weight file: dataset/weights/TMVAClassification_PDERS.weights.xml
: signal and background scales: 0.001 0.001
: Reading weight file: dataset/weights/TMVAClassification_PDEFoam.weights.xml
: Read foams from file: dataset/weights/TMVAClassification_PDEFoam.weights_foams.root
: Reading weight file: dataset/weights/TMVAClassification_KNN.weights.xml
: Creating kd-tree with 2000 events
: Computing scale factor for 1d distributions: (ifrac, bottom, top) = (80%, 10%, 90%)
ModulekNN : Optimizing tree for 4 variables with 2000 values
: <Fill> Class 1 has 1000 events
: <Fill> Class 2 has 1000 events
: Reading weight file: dataset/weights/TMVAClassification_LD.weights.xml
: Reading weight file: dataset/weights/TMVAClassification_FDA_GA.weights.xml
: User-defined formula string : "(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3"
: TFormula-compatible formula string: "[0]+[1]*[5]+[2]*[6]+[3]*[7]+[4]*[8]"
: Reading weight file: dataset/weights/TMVAClassification_MLPBNN.weights.xml
MLPBNN : Building Network.
: Initializing weights
: Reading weight file: dataset/weights/TMVAClassification_DNN_CPU.weights.xml
: Reading weight file: dataset/weights/TMVAClassification_SVM.weights.xml
: Reading weight file: dataset/weights/TMVAClassification_BDT.weights.xml
: Reading weight file: dataset/weights/TMVAClassification_RuleFit.weights.xml
Factory : Test all methods
Factory : Test method: Cuts for Classification performance
:
Cuts : [dataset] : Evaluation of Cuts on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.000574 sec
Factory : Test method: CutsD for Classification performance
:
CutsD : [dataset] : Evaluation of CutsD on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.00523 sec
Factory : Test method: Likelihood for Classification performance
:
Likelihood : [dataset] : Evaluation of Likelihood on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.0077 sec
Factory : Test method: LikelihoodPCA for Classification performance
:
LikelihoodPCA : [dataset] : Evaluation of LikelihoodPCA on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.0176 sec
Factory : Test method: PDERS for Classification performance
:
PDERS : [dataset] : Evaluation of PDERS on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.946 sec
Factory : Test method: PDEFoam for Classification performance
:
PDEFoam : [dataset] : Evaluation of PDEFoam on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.0697 sec
Factory : Test method: KNN for Classification performance
:
KNN : [dataset] : Evaluation of KNN on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.19 sec
Factory : Test method: LD for Classification performance
:
LD : [dataset] : Evaluation of LD on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.00186 sec
: Dataset[dataset] : Evaluation of LD on testing sample
Factory : Test method: FDA_GA for Classification performance
:
FDA_GA : [dataset] : Evaluation of FDA_GA on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.00126 sec
Factory : Test method: MLPBNN for Classification performance
:
MLPBNN : [dataset] : Evaluation of MLPBNN on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.0165 sec
Factory : Test method: DNN_CPU for Classification performance
:
: Evaluate deep neural network on CPU using batches with size = 1000
:
TFHandler_DNN_CPU : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.12216 0.20255 [ -1.0614 1.0246 ]
: myvar2: -0.12333 0.30492 [ -1.2280 0.99911 ]
: var3: 0.097148 0.21347 [ -1.0158 0.99984 ]
: var4: 0.17495 0.23851 [ -1.2661 1.0694 ]
: -----------------------------------------------------------
DNN_CPU : [dataset] : Evaluation of DNN_CPU on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.338 sec
Factory : Test method: SVM for Classification performance
:
SVM : [dataset] : Evaluation of SVM on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.289 sec
Factory : Test method: BDT for Classification performance
:
BDT : [dataset] : Evaluation of BDT on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.562 sec
Factory : Test method: RuleFit for Classification performance
:
RuleFit : [dataset] : Evaluation of RuleFit on testing sample (10000 events)
: Elapsed time for evaluation of 10000 events: 0.011 sec
Factory : Evaluate all methods
Factory : Evaluate classifier: Cuts
:
<WARNING> : You have asked for histogram MVA_EFF_BvsS which does not seem to exist in *Results* .. better don't use it
<WARNING> : You have asked for histogram EFF_BVSS_TR which does not seem to exist in *Results* .. better don't use it
TFHandler_Cuts : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: CutsD
:
<WARNING> : You have asked for histogram MVA_EFF_BvsS which does not seem to exist in *Results* .. better don't use it
TFHandler_CutsD : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.14555 1.0166 [ -5.5736 5.0206 ]
: myvar2: -0.093417 1.0353 [ -3.8442 3.7856 ]
: var3: -0.096857 1.0078 [ -4.5469 4.5058 ]
: var4: 0.65748 0.95864 [ -4.0893 3.7760 ]
: -----------------------------------------------------------
<WARNING> : You have asked for histogram EFF_BVSS_TR which does not seem to exist in *Results* .. better don't use it
TFHandler_CutsD : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.17586 1.0000 [ -5.6401 4.8529 ]
: myvar2: 0.026952 1.0000 [ -2.9292 3.7065 ]
: var3: -0.11549 1.0000 [ -4.1792 3.5180 ]
: var4: 0.34819 1.0000 [ -3.3363 3.3963 ]
: -----------------------------------------------------------
TFHandler_CutsD : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: -0.14555 1.0166 [ -5.5736 5.0206 ]
: myvar2: -0.093417 1.0353 [ -3.8442 3.7856 ]
: var3: -0.096857 1.0078 [ -4.5469 4.5058 ]
: var4: 0.65748 0.95864 [ -4.0893 3.7760 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: Likelihood
:
Likelihood : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_Likelihood : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: LikelihoodPCA
:
TFHandler_LikelihoodPCA : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 1.1147 2.2628 [ -12.508 10.719 ]
: myvar2: -0.25554 1.1225 [ -4.1578 3.8995 ]
: var3: -0.19401 0.58225 [ -2.2950 1.8880 ]
: var4: -0.32038 0.33412 [ -1.3929 0.88819 ]
: -----------------------------------------------------------
LikelihoodPCA : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_LikelihoodPCA : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 1.1147 2.2628 [ -12.508 10.719 ]
: myvar2: -0.25554 1.1225 [ -4.1578 3.8995 ]
: var3: -0.19401 0.58225 [ -2.2950 1.8880 ]
: var4: -0.32038 0.33412 [ -1.3929 0.88819 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: PDERS
:
PDERS : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_PDERS : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: PDEFoam
:
PDEFoam : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_PDEFoam : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: KNN
:
KNN : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_KNN : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: LD
:
LD : [dataset] : Loop over test events and fill histograms with classifier response...
:
: Also filling probability and rarity histograms (on request)...
TFHandler_LD : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: FDA_GA
:
FDA_GA : [dataset] : Loop over test events and fill histograms with classifier response...
:
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.005, fb=-0.005), refValue = 0.005
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.015, fb=-0.015), refValue = 0.015
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.025, fb=-0.025), refValue = 0.025
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.035, fb=-0.035), refValue = 0.035
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.045, fb=-0.045), refValue = 0.045
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.055, fb=-0.055), refValue = 0.055
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.065, fb=-0.065), refValue = 0.065
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.075, fb=-0.075), refValue = 0.075
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.085, fb=-0.085), refValue = 0.085
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.095, fb=-0.095), refValue = 0.095
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.105, fb=-0.105), refValue = 0.105
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.115, fb=-0.115), refValue = 0.115
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.125, fb=-0.125), refValue = 0.125
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.135, fb=-0.135), refValue = 0.135
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.145, fb=-0.145), refValue = 0.145
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.155, fb=-0.155), refValue = 0.155
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.165, fb=-0.165), refValue = 0.165
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.175, fb=-0.175), refValue = 0.175
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.185, fb=-0.185), refValue = 0.185
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.195, fb=-0.195), refValue = 0.195
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.205, fb=-0.205), refValue = 0.205
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.215, fb=-0.215), refValue = 0.215
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.225, fb=-0.225), refValue = 0.225
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.235, fb=-0.235), refValue = 0.235
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.245, fb=-0.245), refValue = 0.245
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.255, fb=-0.255), refValue = 0.255
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.265, fb=-0.265), refValue = 0.265
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.275, fb=-0.275), refValue = 0.275
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.285, fb=-0.285), refValue = 0.285
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.295, fb=-0.295), refValue = 0.295
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.305, fb=-0.305), refValue = 0.305
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.315, fb=-0.315), refValue = 0.315
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.325, fb=-0.325), refValue = 0.325
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.335, fb=-0.335), refValue = 0.335
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.345, fb=-0.345), refValue = 0.345
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.355, fb=-0.355), refValue = 0.355
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.365, fb=-0.365), refValue = 0.365
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.375, fb=-0.375), refValue = 0.375
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.385, fb=-0.385), refValue = 0.385
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.395, fb=-0.395), refValue = 0.395
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.405, fb=-0.405), refValue = 0.405
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.415, fb=-0.415), refValue = 0.415
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.425, fb=-0.425), refValue = 0.425
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.435, fb=-0.435), refValue = 0.435
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.445, fb=-0.445), refValue = 0.445
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.455, fb=-0.455), refValue = 0.455
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.465, fb=-0.465), refValue = 0.465
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.475, fb=-0.475), refValue = 0.475
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.485, fb=-0.485), refValue = 0.485
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.495, fb=-0.495), refValue = 0.495
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.505, fb=-0.505), refValue = 0.505
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.515, fb=-0.515), refValue = 0.515
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.525, fb=-0.525), refValue = 0.525
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.535, fb=-0.535), refValue = 0.535
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.545, fb=-0.545), refValue = 0.545
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.555, fb=-0.555), refValue = 0.555
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.565, fb=-0.565), refValue = 0.565
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.575, fb=-0.575), refValue = 0.575
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.585, fb=-0.585), refValue = 0.585
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.595, fb=-0.595), refValue = 0.595
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.605, fb=-0.605), refValue = 0.605
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.615, fb=-0.615), refValue = 0.615
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.625, fb=-0.625), refValue = 0.625
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.635, fb=-0.635), refValue = 0.635
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.645, fb=-0.645), refValue = 0.645
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.655, fb=-0.655), refValue = 0.655
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.665, fb=-0.665), refValue = 0.665
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.675, fb=-0.675), refValue = 0.675
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.685, fb=-0.685), refValue = 0.685
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.695, fb=-0.695), refValue = 0.695
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.705, fb=-0.705), refValue = 0.705
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.715, fb=-0.715), refValue = 0.715
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.725, fb=-0.725), refValue = 0.725
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.735, fb=-0.735), refValue = 0.735
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.745, fb=-0.745), refValue = 0.745
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.755, fb=-0.755), refValue = 0.755
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.765, fb=-0.765), refValue = 0.765
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.775, fb=-0.775), refValue = 0.775
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.785, fb=-0.785), refValue = 0.785
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.795, fb=-0.795), refValue = 0.795
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.805, fb=-0.805), refValue = 0.805
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.815, fb=-0.815), refValue = 0.815
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.825, fb=-0.825), refValue = 0.825
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.835, fb=-0.835), refValue = 0.835
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.845, fb=-0.845), refValue = 0.845
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.855, fb=-0.855), refValue = 0.855
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.865, fb=-0.865), refValue = 0.865
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.875, fb=-0.875), refValue = 0.875
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.885, fb=-0.885), refValue = 0.885
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.895, fb=-0.895), refValue = 0.895
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.905, fb=-0.905), refValue = 0.905
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.915, fb=-0.915), refValue = 0.915
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.925, fb=-0.925), refValue = 0.925
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.935, fb=-0.935), refValue = 0.935
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.945, fb=-0.945), refValue = 0.945
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.955, fb=-0.955), refValue = 0.955
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.965, fb=-0.965), refValue = 0.965
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.975, fb=-0.975), refValue = 0.975
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.985, fb=-0.985), refValue = 0.985
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.995, fb=-0.995), refValue = 0.995
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.9999, fb=-0.9999), refValue = 0.9999
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.005, fb=-0.005), refValue = 0.005
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.015, fb=-0.015), refValue = 0.015
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.025, fb=-0.025), refValue = 0.025
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.035, fb=-0.035), refValue = 0.035
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.045, fb=-0.045), refValue = 0.045
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.055, fb=-0.055), refValue = 0.055
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.065, fb=-0.065), refValue = 0.065
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.075, fb=-0.075), refValue = 0.075
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.085, fb=-0.085), refValue = 0.085
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.095, fb=-0.095), refValue = 0.095
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.105, fb=-0.105), refValue = 0.105
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.115, fb=-0.115), refValue = 0.115
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.125, fb=-0.125), refValue = 0.125
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.135, fb=-0.135), refValue = 0.135
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.145, fb=-0.145), refValue = 0.145
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.155, fb=-0.155), refValue = 0.155
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.165, fb=-0.165), refValue = 0.165
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.175, fb=-0.175), refValue = 0.175
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.185, fb=-0.185), refValue = 0.185
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.195, fb=-0.195), refValue = 0.195
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.205, fb=-0.205), refValue = 0.205
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.215, fb=-0.215), refValue = 0.215
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.225, fb=-0.225), refValue = 0.225
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.235, fb=-0.235), refValue = 0.235
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.245, fb=-0.245), refValue = 0.245
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.255, fb=-0.255), refValue = 0.255
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.265, fb=-0.265), refValue = 0.265
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.275, fb=-0.275), refValue = 0.275
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.285, fb=-0.285), refValue = 0.285
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.295, fb=-0.295), refValue = 0.295
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.305, fb=-0.305), refValue = 0.305
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.315, fb=-0.315), refValue = 0.315
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.325, fb=-0.325), refValue = 0.325
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.335, fb=-0.335), refValue = 0.335
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.345, fb=-0.345), refValue = 0.345
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.355, fb=-0.355), refValue = 0.355
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.365, fb=-0.365), refValue = 0.365
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.375, fb=-0.375), refValue = 0.375
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.385, fb=-0.385), refValue = 0.385
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.395, fb=-0.395), refValue = 0.395
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.405, fb=-0.405), refValue = 0.405
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.415, fb=-0.415), refValue = 0.415
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.425, fb=-0.425), refValue = 0.425
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.435, fb=-0.435), refValue = 0.435
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.445, fb=-0.445), refValue = 0.445
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.455, fb=-0.455), refValue = 0.455
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.465, fb=-0.465), refValue = 0.465
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.475, fb=-0.475), refValue = 0.475
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.485, fb=-0.485), refValue = 0.485
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.495, fb=-0.495), refValue = 0.495
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.505, fb=-0.505), refValue = 0.505
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.515, fb=-0.515), refValue = 0.515
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.525, fb=-0.525), refValue = 0.525
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.535, fb=-0.535), refValue = 0.535
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.545, fb=-0.545), refValue = 0.545
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.555, fb=-0.555), refValue = 0.555
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.565, fb=-0.565), refValue = 0.565
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.575, fb=-0.575), refValue = 0.575
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.585, fb=-0.585), refValue = 0.585
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.595, fb=-0.595), refValue = 0.595
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.605, fb=-0.605), refValue = 0.605
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.615, fb=-0.615), refValue = 0.615
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.625, fb=-0.625), refValue = 0.625
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.635, fb=-0.635), refValue = 0.635
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.645, fb=-0.645), refValue = 0.645
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.655, fb=-0.655), refValue = 0.655
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.665, fb=-0.665), refValue = 0.665
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.675, fb=-0.675), refValue = 0.675
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.685, fb=-0.685), refValue = 0.685
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.695, fb=-0.695), refValue = 0.695
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.705, fb=-0.705), refValue = 0.705
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.715, fb=-0.715), refValue = 0.715
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.725, fb=-0.725), refValue = 0.725
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.735, fb=-0.735), refValue = 0.735
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.745, fb=-0.745), refValue = 0.745
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.755, fb=-0.755), refValue = 0.755
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.765, fb=-0.765), refValue = 0.765
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.775, fb=-0.775), refValue = 0.775
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.785, fb=-0.785), refValue = 0.785
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.795, fb=-0.795), refValue = 0.795
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.805, fb=-0.805), refValue = 0.805
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.815, fb=-0.815), refValue = 0.815
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.825, fb=-0.825), refValue = 0.825
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.835, fb=-0.835), refValue = 0.835
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.845, fb=-0.845), refValue = 0.845
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.855, fb=-0.855), refValue = 0.855
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.865, fb=-0.865), refValue = 0.865
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.875, fb=-0.875), refValue = 0.875
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.885, fb=-0.885), refValue = 0.885
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.895, fb=-0.895), refValue = 0.895
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.905, fb=-0.905), refValue = 0.905
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.915, fb=-0.915), refValue = 0.915
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.925, fb=-0.925), refValue = 0.925
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.935, fb=-0.935), refValue = 0.935
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.945, fb=-0.945), refValue = 0.945
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.955, fb=-0.955), refValue = 0.955
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.965, fb=-0.965), refValue = 0.965
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.975, fb=-0.975), refValue = 0.975
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.985, fb=-0.985), refValue = 0.985
<WARNING> : <Root> initial interval w/o root: (a=0.516172, b=0.516172), (Eff_a=0, Eff_b=0), (fa=-0.995, fb=-0.995), refValue = 0.995
TFHandler_FDA_GA : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: MLPBNN
:
TFHandler_MLPBNN : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.12216 0.20255 [ -1.0614 1.0246 ]
: myvar2: -0.12333 0.30492 [ -1.2280 0.99911 ]
: var3: 0.097148 0.21347 [ -1.0158 0.99984 ]
: var4: 0.17495 0.23851 [ -1.2661 1.0694 ]
: -----------------------------------------------------------
MLPBNN : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_MLPBNN : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.12216 0.20255 [ -1.0614 1.0246 ]
: myvar2: -0.12333 0.30492 [ -1.2280 0.99911 ]
: var3: 0.097148 0.21347 [ -1.0158 0.99984 ]
: var4: 0.17495 0.23851 [ -1.2661 1.0694 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: DNN_CPU
:
DNN_CPU : [dataset] : Loop over test events and fill histograms with classifier response...
:
: Evaluate deep neural network on CPU using batches with size = 1000
:
TFHandler_DNN_CPU : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.089214 0.20183 [ -1.0000 1.0000 ]
: myvar2: -0.090751 0.29609 [ -1.0000 1.0000 ]
: var3: 0.059878 0.21436 [ -1.0000 1.0000 ]
: var4: 0.11587 0.24261 [ -1.0000 1.0000 ]
: -----------------------------------------------------------
TFHandler_DNN_CPU : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.12216 0.20255 [ -1.0614 1.0246 ]
: myvar2: -0.12333 0.30492 [ -1.2280 0.99911 ]
: var3: 0.097148 0.21347 [ -1.0158 0.99984 ]
: var4: 0.17495 0.23851 [ -1.2661 1.0694 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: SVM
:
TFHandler_SVM : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.12216 0.20255 [ -1.0614 1.0246 ]
: myvar2: -0.12333 0.30492 [ -1.2280 0.99911 ]
: var3: 0.097148 0.21347 [ -1.0158 0.99984 ]
: var4: 0.17495 0.23851 [ -1.2661 1.0694 ]
: -----------------------------------------------------------
SVM : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_SVM : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.12216 0.20255 [ -1.0614 1.0246 ]
: myvar2: -0.12333 0.30492 [ -1.2280 0.99911 ]
: var3: 0.097148 0.21347 [ -1.0158 0.99984 ]
: var4: 0.17495 0.23851 [ -1.2661 1.0694 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: BDT
:
BDT : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_BDT : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
Factory : Evaluate classifier: RuleFit
:
RuleFit : [dataset] : Loop over test events and fill histograms with classifier response...
:
TFHandler_RuleFit : Variable Mean RMS [ Min Max ]
: -----------------------------------------------------------
: myvar1: 0.21781 1.7248 [ -9.8605 7.9024 ]
: myvar2: -0.062175 1.1106 [ -4.0854 4.0259 ]
: var3: 0.16451 1.0589 [ -5.3563 4.6422 ]
: var4: 0.43566 1.2253 [ -6.9675 5.0307 ]
: -----------------------------------------------------------
:
: Evaluation results ranked by best signal efficiency and purity (area)
: -------------------------------------------------------------------------------------------------------------------
: DataSet MVA
: Name: Method: ROC-integ
: dataset LD : 0.921
: dataset DNN_CPU : 0.921
: dataset MLPBNN : 0.919
: dataset LikelihoodPCA : 0.914
: dataset CutsD : 0.908
: dataset SVM : 0.898
: dataset RuleFit : 0.881
: dataset BDT : 0.881
: dataset KNN : 0.838
: dataset PDEFoam : 0.822
: dataset PDERS : 0.797
: dataset Cuts : 0.792
: dataset Likelihood : 0.757
: dataset FDA_GA : 0.494
: -------------------------------------------------------------------------------------------------------------------
:
: Testing efficiency compared to training efficiency (overtraining check)
: -------------------------------------------------------------------------------------------------------------------
: DataSet MVA Signal efficiency: from test sample (from training sample)
: Name: Method: @B=0.01 @B=0.10 @B=0.30
: -------------------------------------------------------------------------------------------------------------------
: dataset LD : 0.364 (0.438) 0.781 (0.758) 0.929 (0.920)
: dataset DNN_CPU : 0.368 (0.427) 0.780 (0.754) 0.927 (0.920)
: dataset MLPBNN : 0.343 (0.432) 0.777 (0.768) 0.926 (0.920)
: dataset LikelihoodPCA : 0.308 (0.345) 0.757 (0.728) 0.920 (0.911)
: dataset CutsD : 0.262 (0.449) 0.735 (0.709) 0.914 (0.890)
: dataset SVM : 0.321 (0.332) 0.711 (0.725) 0.894 (0.898)
: dataset RuleFit : 0.075 (0.077) 0.667 (0.718) 0.893 (0.896)
: dataset BDT : 0.275 (0.402) 0.661 (0.731) 0.870 (0.899)
: dataset KNN : 0.195 (0.252) 0.561 (0.642) 0.810 (0.843)
: dataset PDEFoam : 0.173 (0.219) 0.499 (0.541) 0.761 (0.773)
: dataset PDERS : 0.158 (0.171) 0.465 (0.492) 0.750 (0.756)
: dataset Cuts : 0.112 (0.133) 0.444 (0.496) 0.741 (0.758)
: dataset Likelihood : 0.076 (0.089) 0.389 (0.420) 0.686 (0.692)
: dataset FDA_GA : 0.000 (1.000) 0.000 (1.000) 0.000 (1.000)
: -------------------------------------------------------------------------------------------------------------------
:
Dataset:dataset : Created tree 'TestTree' with 10000 events
:
Dataset:dataset : Created tree 'TrainTree' with 2000 events
:
Factory : Thank you for using TMVA!
: For citation information, please visit: http://tmva.sf.net/citeTMVA.html
==> Wrote root file: TMVA.root
==> TMVAClassification is done!
(int) 0
#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include "TChain.h"
#include "TFile.h"
#include "TTree.h"
#include "TString.h"
#include "TObjString.h"
#include "TSystem.h"
#include "TROOT.h"
#include "TMVA/Factory.h"
#include "TMVA/Tools.h"
#include "TMVA/TMVAGui.h"
int TMVAClassification( TString myMethodList = "" )
{
// The explicit loading of the shared libTMVA is done in TMVAlogon.C, defined in .rootrc
// if you use your private .rootrc, or run from a different directory, please copy the
// corresponding lines from .rootrc
// Methods to be processed can be given as an argument; use format:
//
// mylinux~> root -l TMVAClassification.C\(\"myMethod1,myMethod2,myMethod3\"\)
//---------------------------------------------------------------
// This loads the library
// Default MVA methods to be trained + tested
std::map<std::string,int> Use;
// Cut optimisation
Use["Cuts"] = 1;
Use["CutsD"] = 1;
Use["CutsPCA"] = 0;
Use["CutsGA"] = 0;
Use["CutsSA"] = 0;
//
// 1-dimensional likelihood ("naive Bayes estimator")
Use["Likelihood"] = 1;
Use["LikelihoodD"] = 0; // the "D" extension indicates decorrelated input variables (see option strings)
Use["LikelihoodPCA"] = 1; // the "PCA" extension indicates PCA-transformed input variables (see option strings)
Use["LikelihoodKDE"] = 0;
Use["LikelihoodMIX"] = 0;
//
// Mutidimensional likelihood and Nearest-Neighbour methods
Use["PDERS"] = 1;
Use["PDERSD"] = 0;
Use["PDERSPCA"] = 0;
Use["PDEFoam"] = 1;
Use["PDEFoamBoost"] = 0; // uses generalised MVA method boosting
Use["KNN"] = 1; // k-nearest neighbour method
//
// Linear Discriminant Analysis
Use["LD"] = 1; // Linear Discriminant identical to Fisher
Use["Fisher"] = 0;
Use["FisherG"] = 0;
Use["BoostedFisher"] = 0; // uses generalised MVA method boosting
Use["HMatrix"] = 0;
//
// Function Discriminant analysis
Use["FDA_GA"] = 1; // minimisation of user-defined function using Genetics Algorithm
Use["FDA_SA"] = 0;
Use["FDA_MC"] = 0;
Use["FDA_MT"] = 0;
Use["FDA_GAMT"] = 0;
Use["FDA_MCMT"] = 0;
//
// Neural Networks (all are feed-forward Multilayer Perceptrons)
Use["MLP"] = 0; // Recommended ANN
Use["MLPBFGS"] = 0; // Recommended ANN with optional training method
Use["MLPBNN"] = 1; // Recommended ANN with BFGS training method and bayesian regulator
Use["CFMlpANN"] = 0; // Depreciated ANN from ALEPH
Use["TMlpANN"] = 0; // ROOT's own ANN
#ifdef R__HAS_TMVAGPU
Use["DNN_GPU"] = 1; // CUDA-accelerated DNN training.
#else
Use["DNN_GPU"] = 0;
#endif
#ifdef R__HAS_TMVACPU
Use["DNN_CPU"] = 1; // Multi-core accelerated DNN.
#else
Use["DNN_CPU"] = 0;
#endif
//
// Support Vector Machine
Use["SVM"] = 1;
//
// Boosted Decision Trees
Use["BDT"] = 1; // uses Adaptive Boost
Use["BDTG"] = 0; // uses Gradient Boost
Use["BDTB"] = 0; // uses Bagging
Use["BDTD"] = 0; // decorrelation + Adaptive Boost
Use["BDTF"] = 0; // allow usage of fisher discriminant for node splitting
//
// Friedman's RuleFit method, ie, an optimised series of cuts ("rules")
Use["RuleFit"] = 1;
// ---------------------------------------------------------------
std::cout << std::endl;
std::cout << "==> Start TMVAClassification" << std::endl;
// Select methods (don't look at this code - not of interest)
if (myMethodList != "") {
for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0;
std::vector<TString> mlist = TMVA::gTools().SplitString( myMethodList, ',' );
for (UInt_t i=0; i<mlist.size(); i++) {
std::string regMethod(mlist[i]);
if (Use.find(regMethod) == Use.end()) {
std::cout << "Method \"" << regMethod << "\" not known in TMVA under this name. Choose among the following:" << std::endl;
for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) std::cout << it->first << " ";
std::cout << std::endl;
return 1;
}
Use[regMethod] = 1;
}
}
// --------------------------------------------------------------------------------------------------
// Here the preparation phase begins
// Read training and test data
// (it is also possible to use ASCII format as input -> see TMVA Users Guide)
TFile *input(0);
TString fname = "./tmva_class_example.root";
if (!gSystem->AccessPathName( fname )) {
input = TFile::Open( fname ); // check if file in local directory exists
}
else {
input = TFile::Open("http://root.cern.ch/files/tmva_class_example.root", "CACHEREAD");
}
if (!input) {
std::cout << "ERROR: could not open data file" << std::endl;
exit(1);
}
std::cout << "--- TMVAClassification : Using input file: " << input->GetName() << std::endl;
// Register the training and test trees
TTree *signalTree = (TTree*)input->Get("TreeS");
TTree *background = (TTree*)input->Get("TreeB");
// Create a ROOT output file where TMVA will store ntuples, histograms, etc.
TString outfileName( "TMVA.root" );
TFile* outputFile = TFile::Open( outfileName, "RECREATE" );
// Create the factory object. Later you can choose the methods
// whose performance you'd like to investigate. The factory is
// the only TMVA object you have to interact with
//
// The first argument is the base of the name of all the
// weightfiles in the directory weight/
//
// The second argument is the output file for the training results
// All TMVA output can be suppressed by removing the "!" (not) in
// front of the "Silent" argument in the option string
TMVA::Factory *factory = new TMVA::Factory( "TMVAClassification", outputFile,
"!V:!Silent:Color:DrawProgressBar:Transformations=I;D;P;G,D:AnalysisType=Classification" );
TMVA::DataLoader *dataloader=new TMVA::DataLoader("dataset");
// If you wish to modify default settings
// (please check "src/Config.h" to see all available global options)
//
// (TMVA::gConfig().GetVariablePlotting()).fTimesRMS = 8.0;
// (TMVA::gConfig().GetIONames()).fWeightFileDir = "myWeightDirectory";
// Define the input variables that shall be used for the MVA training
// note that you may also use variable expressions, such as: "3*var1/var2*abs(var3)"
// [all types of expressions that can also be parsed by TTree::Draw( "expression" )]
dataloader->AddVariable( "myvar1 := var1+var2", 'F' );
dataloader->AddVariable( "myvar2 := var1-var2", "Expression 2", "", 'F' );
dataloader->AddVariable( "var3", "Variable 3", "units", 'F' );
dataloader->AddVariable( "var4", "Variable 4", "units", 'F' );
// You can add so-called "Spectator variables", which are not used in the MVA training,
// but will appear in the final "TestTree" produced by TMVA. This TestTree will contain the
// input variables, the response values of all trained MVAs, and the spectator variables
dataloader->AddSpectator( "spec1 := var1*2", "Spectator 1", "units", 'F' );
dataloader->AddSpectator( "spec2 := var1*3", "Spectator 2", "units", 'F' );
// global event weights per tree (see below for setting event-wise weights)
Double_t signalWeight = 1.0;
Double_t backgroundWeight = 1.0;
// You can add an arbitrary number of signal or background trees
dataloader->AddSignalTree ( signalTree, signalWeight );
dataloader->AddBackgroundTree( background, backgroundWeight );
// To give different trees for training and testing, do as follows:
//
// dataloader->AddSignalTree( signalTrainingTree, signalTrainWeight, "Training" );
// dataloader->AddSignalTree( signalTestTree, signalTestWeight, "Test" );
// Use the following code instead of the above two or four lines to add signal and background
// training and test events "by hand"
// NOTE that in this case one should not give expressions (such as "var1+var2") in the input
// variable definition, but simply compute the expression before adding the event
// ```cpp
// // --- begin ----------------------------------------------------------
// std::vector<Double_t> vars( 4 ); // vector has size of number of input variables
// Float_t treevars[4], weight;
//
// // Signal
// for (UInt_t ivar=0; ivar<4; ivar++) signalTree->SetBranchAddress( Form( "var%i", ivar+1 ), &(treevars[ivar]) );
// for (UInt_t i=0; i<signalTree->GetEntries(); i++) {
// signalTree->GetEntry(i);
// for (UInt_t ivar=0; ivar<4; ivar++) vars[ivar] = treevars[ivar];
// // add training and test events; here: first half is training, second is testing
// // note that the weight can also be event-wise
// if (i < signalTree->GetEntries()/2.0) dataloader->AddSignalTrainingEvent( vars, signalWeight );
// else dataloader->AddSignalTestEvent ( vars, signalWeight );
// }
//
// // Background (has event weights)
// background->SetBranchAddress( "weight", &weight );
// for (UInt_t ivar=0; ivar<4; ivar++) background->SetBranchAddress( Form( "var%i", ivar+1 ), &(treevars[ivar]) );
// for (UInt_t i=0; i<background->GetEntries(); i++) {
// background->GetEntry(i);
// for (UInt_t ivar=0; ivar<4; ivar++) vars[ivar] = treevars[ivar];
// // add training and test events; here: first half is training, second is testing
// // note that the weight can also be event-wise
// if (i < background->GetEntries()/2) dataloader->AddBackgroundTrainingEvent( vars, backgroundWeight*weight );
// else dataloader->AddBackgroundTestEvent ( vars, backgroundWeight*weight );
// }
// // --- end ------------------------------------------------------------
// ```
// End of tree registration
// Set individual event weights (the variables must exist in the original TTree)
// - for signal : `dataloader->SetSignalWeightExpression ("weight1*weight2");`
// - for background: `dataloader->SetBackgroundWeightExpression("weight1*weight2");`
dataloader->SetBackgroundWeightExpression( "weight" );
// Apply additional cuts on the signal and background samples (can be different)
TCut mycuts = ""; // for example: TCut mycuts = "abs(var1)<0.5 && abs(var2-0.5)<1";
TCut mycutb = ""; // for example: TCut mycutb = "abs(var1)<0.5";
// Tell the dataloader how to use the training and testing events
//
// If no numbers of events are given, half of the events in the tree are used
// for training, and the other half for testing:
//
// dataloader->PrepareTrainingAndTestTree( mycut, "SplitMode=random:!V" );
//
// To also specify the number of testing events, use:
//
// dataloader->PrepareTrainingAndTestTree( mycut,
// "NSigTrain=3000:NBkgTrain=3000:NSigTest=3000:NBkgTest=3000:SplitMode=Random:!V" );
dataloader->PrepareTrainingAndTestTree( mycuts, mycutb,
"nTrain_Signal=1000:nTrain_Background=1000:SplitMode=Random:NormMode=NumEvents:!V" );
// ### Book MVA methods
//
// Please lookup the various method configuration options in the corresponding cxx files, eg:
// src/MethoCuts.cxx, etc, or here: http://tmva.sourceforge.net/optionRef.html
// it is possible to preset ranges in the option string in which the cut optimisation should be done:
// "...:CutRangeMin[2]=-1:CutRangeMax[2]=1"...", where [2] is the third input variable
// Cut optimisation
if (Use["Cuts"])
factory->BookMethod( dataloader, TMVA::Types::kCuts, "Cuts",
"!H:!V:FitMethod=MC:EffSel:SampleSize=200000:VarProp=FSmart" );
if (Use["CutsD"])
factory->BookMethod( dataloader, TMVA::Types::kCuts, "CutsD",
"!H:!V:FitMethod=MC:EffSel:SampleSize=200000:VarProp=FSmart:VarTransform=Decorrelate" );
if (Use["CutsPCA"])
factory->BookMethod( dataloader, TMVA::Types::kCuts, "CutsPCA",
"!H:!V:FitMethod=MC:EffSel:SampleSize=200000:VarProp=FSmart:VarTransform=PCA" );
if (Use["CutsGA"])
factory->BookMethod( dataloader, TMVA::Types::kCuts, "CutsGA",
"H:!V:FitMethod=GA:CutRangeMin[0]=-10:CutRangeMax[0]=10:VarProp[1]=FMax:EffSel:Steps=30:Cycles=3:PopSize=400:SC_steps=10:SC_rate=5:SC_factor=0.95" );
if (Use["CutsSA"])
factory->BookMethod( dataloader, TMVA::Types::kCuts, "CutsSA",
"!H:!V:FitMethod=SA:EffSel:MaxCalls=150000:KernelTemp=IncAdaptive:InitialTemp=1e+6:MinTemp=1e-6:Eps=1e-10:UseDefaultScale" );
// Likelihood ("naive Bayes estimator")
if (Use["Likelihood"])
factory->BookMethod( dataloader, TMVA::Types::kLikelihood, "Likelihood",
"H:!V:TransformOutput:PDFInterpol=Spline2:NSmoothSig[0]=20:NSmoothBkg[0]=20:NSmoothBkg[1]=10:NSmooth=1:NAvEvtPerBin=50" );
// Decorrelated likelihood
if (Use["LikelihoodD"])
factory->BookMethod( dataloader, TMVA::Types::kLikelihood, "LikelihoodD",
"!H:!V:TransformOutput:PDFInterpol=Spline2:NSmoothSig[0]=20:NSmoothBkg[0]=20:NSmooth=5:NAvEvtPerBin=50:VarTransform=Decorrelate" );
// PCA-transformed likelihood
if (Use["LikelihoodPCA"])
factory->BookMethod( dataloader, TMVA::Types::kLikelihood, "LikelihoodPCA",
"!H:!V:!TransformOutput:PDFInterpol=Spline2:NSmoothSig[0]=20:NSmoothBkg[0]=20:NSmooth=5:NAvEvtPerBin=50:VarTransform=PCA" );
// Use a kernel density estimator to approximate the PDFs
if (Use["LikelihoodKDE"])
factory->BookMethod( dataloader, TMVA::Types::kLikelihood, "LikelihoodKDE",
"!H:!V:!TransformOutput:PDFInterpol=KDE:KDEtype=Gauss:KDEiter=Adaptive:KDEFineFactor=0.3:KDEborder=None:NAvEvtPerBin=50" );
// Use a variable-dependent mix of splines and kernel density estimator
if (Use["LikelihoodMIX"])
factory->BookMethod( dataloader, TMVA::Types::kLikelihood, "LikelihoodMIX",
"!H:!V:!TransformOutput:PDFInterpolSig[0]=KDE:PDFInterpolBkg[0]=KDE:PDFInterpolSig[1]=KDE:PDFInterpolBkg[1]=KDE:PDFInterpolSig[2]=Spline2:PDFInterpolBkg[2]=Spline2:PDFInterpolSig[3]=Spline2:PDFInterpolBkg[3]=Spline2:KDEtype=Gauss:KDEiter=Nonadaptive:KDEborder=None:NAvEvtPerBin=50" );
// Test the multi-dimensional probability density estimator
// here are the options strings for the MinMax and RMS methods, respectively:
//
// "!H:!V:VolumeRangeMode=MinMax:DeltaFrac=0.2:KernelEstimator=Gauss:GaussSigma=0.3" );
// "!H:!V:VolumeRangeMode=RMS:DeltaFrac=3:KernelEstimator=Gauss:GaussSigma=0.3" );
if (Use["PDERS"])
factory->BookMethod( dataloader, TMVA::Types::kPDERS, "PDERS",
"!H:!V:NormTree=T:VolumeRangeMode=Adaptive:KernelEstimator=Gauss:GaussSigma=0.3:NEventsMin=400:NEventsMax=600" );
if (Use["PDERSD"])
factory->BookMethod( dataloader, TMVA::Types::kPDERS, "PDERSD",
"!H:!V:VolumeRangeMode=Adaptive:KernelEstimator=Gauss:GaussSigma=0.3:NEventsMin=400:NEventsMax=600:VarTransform=Decorrelate" );
if (Use["PDERSPCA"])
factory->BookMethod( dataloader, TMVA::Types::kPDERS, "PDERSPCA",
"!H:!V:VolumeRangeMode=Adaptive:KernelEstimator=Gauss:GaussSigma=0.3:NEventsMin=400:NEventsMax=600:VarTransform=PCA" );
// Multi-dimensional likelihood estimator using self-adapting phase-space binning
if (Use["PDEFoam"])
factory->BookMethod( dataloader, TMVA::Types::kPDEFoam, "PDEFoam",
"!H:!V:SigBgSeparate=F:TailCut=0.001:VolFrac=0.0666:nActiveCells=500:nSampl=2000:nBin=5:Nmin=100:Kernel=None:Compress=T" );
if (Use["PDEFoamBoost"])
factory->BookMethod( dataloader, TMVA::Types::kPDEFoam, "PDEFoamBoost",
"!H:!V:Boost_Num=30:Boost_Transform=linear:SigBgSeparate=F:MaxDepth=4:UseYesNoCell=T:DTLogic=MisClassificationError:FillFoamWithOrigWeights=F:TailCut=0:nActiveCells=500:nBin=20:Nmin=400:Kernel=None:Compress=T" );
// K-Nearest Neighbour classifier (KNN)
if (Use["KNN"])
factory->BookMethod( dataloader, TMVA::Types::kKNN, "KNN",
"H:nkNN=20:ScaleFrac=0.8:SigmaFact=1.0:Kernel=Gaus:UseKernel=F:UseWeight=T:!Trim" );
// H-Matrix (chi2-squared) method
if (Use["HMatrix"])
factory->BookMethod( dataloader, TMVA::Types::kHMatrix, "HMatrix", "!H:!V:VarTransform=None" );
// Linear discriminant (same as Fisher discriminant)
if (Use["LD"])
factory->BookMethod( dataloader, TMVA::Types::kLD, "LD", "H:!V:VarTransform=None:CreateMVAPdfs:PDFInterpolMVAPdf=Spline2:NbinsMVAPdf=50:NsmoothMVAPdf=10" );
// Fisher discriminant (same as LD)
if (Use["Fisher"])
factory->BookMethod( dataloader, TMVA::Types::kFisher, "Fisher", "H:!V:Fisher:VarTransform=None:CreateMVAPdfs:PDFInterpolMVAPdf=Spline2:NbinsMVAPdf=50:NsmoothMVAPdf=10" );
// Fisher with Gauss-transformed input variables
if (Use["FisherG"])
factory->BookMethod( dataloader, TMVA::Types::kFisher, "FisherG", "H:!V:VarTransform=Gauss" );
// Composite classifier: ensemble (tree) of boosted Fisher classifiers
if (Use["BoostedFisher"])
factory->BookMethod( dataloader, TMVA::Types::kFisher, "BoostedFisher",
"H:!V:Boost_Num=20:Boost_Transform=log:Boost_Type=AdaBoost:Boost_AdaBoostBeta=0.2:!Boost_DetailedMonitoring" );
// Function discrimination analysis (FDA) -- test of various fitters - the recommended one is Minuit (or GA or SA)
if (Use["FDA_MC"])
factory->BookMethod( dataloader, TMVA::Types::kFDA, "FDA_MC",
"H:!V:Formula=(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3:ParRanges=(-1,1);(-10,10);(-10,10);(-10,10);(-10,10):FitMethod=MC:SampleSize=100000:Sigma=0.1" );
if (Use["FDA_GA"]) // can also use Simulated Annealing (SA) algorithm (see Cuts_SA options])
factory->BookMethod( dataloader, TMVA::Types::kFDA, "FDA_GA",
"H:!V:Formula=(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3:ParRanges=(-1,1);(-10,10);(-10,10);(-10,10);(-10,10):FitMethod=GA:PopSize=100:Cycles=2:Steps=5:Trim=True:SaveBestGen=1" );
if (Use["FDA_SA"]) // can also use Simulated Annealing (SA) algorithm (see Cuts_SA options])
factory->BookMethod( dataloader, TMVA::Types::kFDA, "FDA_SA",
"H:!V:Formula=(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3:ParRanges=(-1,1);(-10,10);(-10,10);(-10,10);(-10,10):FitMethod=SA:MaxCalls=15000:KernelTemp=IncAdaptive:InitialTemp=1e+6:MinTemp=1e-6:Eps=1e-10:UseDefaultScale" );
if (Use["FDA_MT"])
factory->BookMethod( dataloader, TMVA::Types::kFDA, "FDA_MT",
"H:!V:Formula=(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3:ParRanges=(-1,1);(-10,10);(-10,10);(-10,10);(-10,10):FitMethod=MINUIT:ErrorLevel=1:PrintLevel=-1:FitStrategy=2:UseImprove:UseMinos:SetBatch" );
if (Use["FDA_GAMT"])
factory->BookMethod( dataloader, TMVA::Types::kFDA, "FDA_GAMT",
"H:!V:Formula=(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3:ParRanges=(-1,1);(-10,10);(-10,10);(-10,10);(-10,10):FitMethod=GA:Converger=MINUIT:ErrorLevel=1:PrintLevel=-1:FitStrategy=0:!UseImprove:!UseMinos:SetBatch:Cycles=1:PopSize=5:Steps=5:Trim" );
if (Use["FDA_MCMT"])
factory->BookMethod( dataloader, TMVA::Types::kFDA, "FDA_MCMT",
"H:!V:Formula=(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3:ParRanges=(-1,1);(-10,10);(-10,10);(-10,10);(-10,10):FitMethod=MC:Converger=MINUIT:ErrorLevel=1:PrintLevel=-1:FitStrategy=0:!UseImprove:!UseMinos:SetBatch:SampleSize=20" );
// TMVA ANN: MLP (recommended ANN) -- all ANNs in TMVA are Multilayer Perceptrons
if (Use["MLP"])
factory->BookMethod( dataloader, TMVA::Types::kMLP, "MLP", "H:!V:NeuronType=tanh:VarTransform=N:NCycles=600:HiddenLayers=N+5:TestRate=5:!UseRegulator" );
if (Use["MLPBFGS"])
factory->BookMethod( dataloader, TMVA::Types::kMLP, "MLPBFGS", "H:!V:NeuronType=tanh:VarTransform=N:NCycles=600:HiddenLayers=N+5:TestRate=5:TrainingMethod=BFGS:!UseRegulator" );
if (Use["MLPBNN"])
factory->BookMethod( dataloader, TMVA::Types::kMLP, "MLPBNN", "H:!V:NeuronType=tanh:VarTransform=N:NCycles=60:HiddenLayers=N+5:TestRate=5:TrainingMethod=BFGS:UseRegulator" ); // BFGS training with bayesian regulators
// Multi-architecture DNN implementation.
if (Use["DNN_CPU"] or Use["DNN_GPU"]) {
// General layout.
TString layoutString ("Layout=TANH|128,TANH|128,TANH|128,LINEAR");
// Define Training strategy. One could define multiple stratgey string separated by the "|" delimiter
TString trainingStrategyString = ("TrainingStrategy=LearningRate=1e-2,Momentum=0.9,"
"ConvergenceSteps=20,BatchSize=100,TestRepetitions=1,"
"WeightDecay=1e-4,Regularization=None,"
"DropConfig=0.0+0.5+0.5+0.5");
// General Options.
TString dnnOptions ("!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:"
"WeightInitialization=XAVIERUNIFORM");
dnnOptions.Append (":"); dnnOptions.Append (layoutString);
dnnOptions.Append (":"); dnnOptions.Append (trainingStrategyString);
// Cuda implementation.
if (Use["DNN_GPU"]) {
TString gpuOptions = dnnOptions + ":Architecture=GPU";
factory->BookMethod(dataloader, TMVA::Types::kDL, "DNN_GPU", gpuOptions);
}
// Multi-core CPU implementation.
if (Use["DNN_CPU"]) {
TString cpuOptions = dnnOptions + ":Architecture=CPU";
factory->BookMethod(dataloader, TMVA::Types::kDL, "DNN_CPU", cpuOptions);
}
}
// CF(Clermont-Ferrand)ANN
if (Use["CFMlpANN"])
factory->BookMethod( dataloader, TMVA::Types::kCFMlpANN, "CFMlpANN", "!H:!V:NCycles=200:HiddenLayers=N+1,N" ); // n_cycles:#nodes:#nodes:...
// Tmlp(Root)ANN
if (Use["TMlpANN"])
factory->BookMethod( dataloader, TMVA::Types::kTMlpANN, "TMlpANN", "!H:!V:NCycles=200:HiddenLayers=N+1,N:LearningMethod=BFGS:ValidationFraction=0.3" ); // n_cycles:#nodes:#nodes:...
// Support Vector Machine
if (Use["SVM"])
factory->BookMethod( dataloader, TMVA::Types::kSVM, "SVM", "Gamma=0.25:Tol=0.001:VarTransform=Norm" );
// Boosted Decision Trees
if (Use["BDTG"]) // Gradient Boost
factory->BookMethod( dataloader, TMVA::Types::kBDT, "BDTG",
"!H:!V:NTrees=1000:MinNodeSize=2.5%:BoostType=Grad:Shrinkage=0.10:UseBaggedBoost:BaggedSampleFraction=0.5:nCuts=20:MaxDepth=2" );
if (Use["BDT"]) // Adaptive Boost
factory->BookMethod( dataloader, TMVA::Types::kBDT, "BDT",
"!H:!V:NTrees=850:MinNodeSize=2.5%:MaxDepth=3:BoostType=AdaBoost:AdaBoostBeta=0.5:UseBaggedBoost:BaggedSampleFraction=0.5:SeparationType=GiniIndex:nCuts=20" );
if (Use["BDTB"]) // Bagging
factory->BookMethod( dataloader, TMVA::Types::kBDT, "BDTB",
"!H:!V:NTrees=400:BoostType=Bagging:SeparationType=GiniIndex:nCuts=20" );
if (Use["BDTD"]) // Decorrelation + Adaptive Boost
factory->BookMethod( dataloader, TMVA::Types::kBDT, "BDTD",
"!H:!V:NTrees=400:MinNodeSize=5%:MaxDepth=3:BoostType=AdaBoost:SeparationType=GiniIndex:nCuts=20:VarTransform=Decorrelate" );
if (Use["BDTF"]) // Allow Using Fisher discriminant in node splitting for (strong) linearly correlated variables
factory->BookMethod( dataloader, TMVA::Types::kBDT, "BDTF",
"!H:!V:NTrees=50:MinNodeSize=2.5%:UseFisherCuts:MaxDepth=3:BoostType=AdaBoost:AdaBoostBeta=0.5:SeparationType=GiniIndex:nCuts=20" );
// RuleFit -- TMVA implementation of Friedman's method
if (Use["RuleFit"])
factory->BookMethod( dataloader, TMVA::Types::kRuleFit, "RuleFit",
"H:!V:RuleFitModule=RFTMVA:Model=ModRuleLinear:MinImp=0.001:RuleMinDist=0.001:NTrees=20:fEventsMin=0.01:fEventsMax=0.5:GDTau=-1.0:GDTauPrec=0.01:GDStep=0.01:GDNSteps=10000:GDErrScale=1.02" );
// For an example of the category classifier usage, see: TMVAClassificationCategory
//
// --------------------------------------------------------------------------------------------------
// Now you can optimize the setting (configuration) of the MVAs using the set of training events
// STILL EXPERIMENTAL and only implemented for BDT's !
//
// factory->OptimizeAllMethods("SigEffAtBkg0.01","Scan");
// factory->OptimizeAllMethods("ROCIntegral","FitGA");
//
// --------------------------------------------------------------------------------------------------
// Now you can tell the factory to train, test, and evaluate the MVAs
//
// Train MVAs using the set of training events
factory->TrainAllMethods();
// Evaluate all MVAs using the set of test events
factory->TestAllMethods();
// Evaluate and compare performance of all configured MVAs
factory->EvaluateAllMethods();
// --------------------------------------------------------------
// Save the output
outputFile->Close();
std::cout << "==> Wrote root file: " << outputFile->GetName() << std::endl;
std::cout << "==> TMVAClassification is done!" << std::endl;
delete factory;
delete dataloader;
// Launch the GUI for the root macros
if (!gROOT->IsBatch()) TMVA::TMVAGui( outfileName );
return 0;
}
int main( int argc, char** argv )
{
// Select methods (don't look at this code - not of interest)
TString methodList;
for (int i=1; i<argc; i++) {
TString regMethod(argv[i]);
if(regMethod=="-b" || regMethod=="--batch") continue;
if (!methodList.IsNull()) methodList += TString(",");
methodList += regMethod;
}
return TMVAClassification(methodList);
}
Author
Andreas Hoecker

Definition in file TMVAClassification.C.

TCut
Definition: TCut.h:25
TMVA::Types::kTMlpANN
@ kTMlpANN
Definition: Types.h:110
TMVA::DataLoader::PrepareTrainingAndTestTree
void PrepareTrainingAndTestTree(const TCut &cut, const TString &splitOpt)
prepare the training and test trees -> same cuts for signal and background
Definition: DataLoader.cxx:631
TMVA::Tools::SplitString
std::vector< TString > SplitString(const TString &theOpt, const char separator) const
splits the option string at 'separator' and fills the list 'splitV' with the primitive strings
Definition: Tools.cxx:1211
TFile::SetCacheFileDir
static Bool_t SetCacheFileDir(ROOT::Internal::TStringView cacheDir, Bool_t operateDisconnected=kTRUE, Bool_t forceCacheread=kFALSE)
Definition: TFile.h:324
TObjString.h
TMVA::Types::kBDT
@ kBDT
Definition: Types.h:111
TTree
Definition: TTree.h:79
DataLoader.h
TFile::Open
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition: TFile.cxx:3946
TMVA::Factory::TestAllMethods
void TestAllMethods()
Evaluates all booked methods on the testing data and adds the output to the Results in the corresponi...
Definition: Factory.cxx:1241
TMVA::Types::kSVM
@ kSVM
Definition: Types.h:114
TMVAGui.h
TTree.h
TMVA::DataLoader::AddSignalTree
void AddSignalTree(TTree *signal, Double_t weight=1.0, Types::ETreeType treetype=Types::kMaxTreeType)
number of signal events (used to compute significance)
Definition: DataLoader.cxx:370
TString
Definition: TString.h:136
TSystem::AccessPathName
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition: TSystem.cxx:1294
TMVA::Types::kLD
@ kLD
Definition: Types.h:120
TString.h
TFile.h
TMVA::Types::kLikelihood
@ kLikelihood
Definition: Types.h:104
TMVA::DataLoader::AddSpectator
void AddSpectator(const TString &expression, const TString &title="", const TString &unit="", Double_t min=0, Double_t max=0)
user inserts target in data set info
Definition: DataLoader.cxx:523
TROOT.h
TMVA::Types::kPDEFoam
@ kPDEFoam
Definition: Types.h:119
TMVA::Types::kCuts
@ kCuts
Definition: Types.h:103
TMVA::Types::kHMatrix
@ kHMatrix
Definition: Types.h:106
TMVA::Types::kKNN
@ kKNN
Definition: Types.h:108
TMVA::DataLoader::SetBackgroundWeightExpression
void SetBackgroundWeightExpression(const TString &variable)
Definition: DataLoader.cxx:555
TMVA::Types::kCFMlpANN
@ kCFMlpANN
Definition: Types.h:109
TChain.h
TMVA::Types::kFisher
@ kFisher
Definition: Types.h:107
TSystem.h
main
int main(int argc, char **argv)
Definition: histspeedtest.cxx:751
TMVA::Types::kRuleFit
@ kRuleFit
Definition: Types.h:113
TMVA::Factory
Definition: Factory.h:80
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
TFile
Definition: TFile.h:54
TMVA::Types::kPDERS
@ kPDERS
Definition: Types.h:105
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
TMVA::Tools::Instance
static Tools & Instance()
Definition: Tools.cxx:75
TMVA::Factory::BookMethod
MethodBase * BookMethod(DataLoader *loader, TString theMethodName, TString methodTitle, TString theOption="")
Book a classifier or regression method.
Definition: Factory.cxx:342
TMVA::Types::kDL
@ kDL
Definition: Types.h:124
TString::IsNull
Bool_t IsNull() const
Definition: TString.h:407
Double_t
double Double_t
Definition: RtypesCore.h:59
TMVA::Types::kMLP
@ kMLP
Definition: Types.h:115
TFile::Close
void Close(Option_t *option="") override
Close a file.
Definition: TFile.cxx:876
Factory.h
TMVA::Types::kFDA
@ kFDA
Definition: Types.h:117
TMVA::TMVAGui
void TMVAGui(const char *fName="TMVA.root", TString dataset="")
TMVA::DataLoader::AddBackgroundTree
void AddBackgroundTree(TTree *background, Double_t weight=1.0, Types::ETreeType treetype=Types::kMaxTreeType)
number of signal events (used to compute significance)
Definition: DataLoader.cxx:401
Tools.h
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
TMVA::Factory::EvaluateAllMethods
void EvaluateAllMethods(void)
Iterates over all MVAs that have been booked, and calls their evaluation methods.
Definition: Factory.cxx:1346
TMVA::Factory::TrainAllMethods
void TrainAllMethods()
Iterates through all booked methods and calls training.
Definition: Factory.cxx:1090
TMVA::DataLoader::AddVariable
void AddVariable(const TString &expression, const TString &title, const TString &unit, char type='F', Double_t min=0, Double_t max=0)
user inserts discriminating variable in data set info
Definition: DataLoader.cxx:484
TMVA::gTools
Tools & gTools()
TCollection::GetName
virtual const char * GetName() const
Return name of this collection.
Definition: TCollection.cxx:351
gROOT
#define gROOT
Definition: TROOT.h:406
TMVA::DataLoader
Definition: DataLoader.h:50