Execution Time41.58s

Test: tutorial-tmva-TMVAClassification (Passed)
Build: v6-18-00-patches-x86_64-mac1015-clang110-opt (macitois17.cern.ch) on 2019-11-14 00:46:16

Test Timing: Passed
Processors1

Show Command Line
Display graphs:

Test output
Processing /Users/sftnight/build/night/LABEL/mac1015/SPEC/noimt/V/6-18/root/tutorials/tmva/TMVAClassification.C...

==> Start TMVAClassification
[TFile::Cp] Total 0.20 MB	|>...................| 0.00 % [0.0 MB/s][TFile::Cp] Total 0.20 MB	|====================| 100.00 % [35.2 MB/s]
Info in <TFile::OpenFromCache>: using local cache copy of http://root.cern.ch/files/tmva_class_example.root [./files/tmva_class_example.root]
--- 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: [NON-XML-CHAR-0x1B][1mCuts[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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: [NON-XML-CHAR-0x1B][1mCutsD[NON-XML-CHAR-0x1B][0m
                         : 
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: [NON-XML-CHAR-0x1B][1mLikelihood[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mLikelihoodPCA[NON-XML-CHAR-0x1B][0m
                         : 
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: [NON-XML-CHAR-0x1B][1mPDERS[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mPDEFoam[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mKNN[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mLD[NON-XML-CHAR-0x1B][0m
                         : 
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):
                         : ----------------------------------------------
                         :            var1+var2 var1-var2    var3    var4
                         : var1+var2:    +1.000    -0.034  +0.771  +0.930
                         : var1-var2:    -0.034    +1.000  -0.100  +0.046
                         :      var3:    +0.771    -0.100  +1.000  +0.856
                         :      var4:    +0.930    +0.046  +0.856  +1.000
                         : ----------------------------------------------
DataSetInfo              : Correlation matrix (Background):
                         : ----------------------------------------------
                         :            var1+var2 var1-var2    var3    var4
                         : var1+var2:    +1.000    -0.009  +0.789  +0.934
                         : var1-var2:    -0.009    +1.000  -0.132  +0.071
                         :      var3:    +0.789    -0.132  +1.000  +0.845
                         :      var4:    +0.934    +0.071  +0.845  +1.000
                         : ----------------------------------------------
DataSetFactory           : [dataset] :  
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mFDA_GA[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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: [NON-XML-CHAR-0x1B][1mMLPBNN[NON-XML-CHAR-0x1B][0m
                         : 
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: [NON-XML-CHAR-0x1B][1mSVM[NON-XML-CHAR-0x1B][0m
                         : 
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: [NON-XML-CHAR-0x1B][1mBDT[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mRuleFit[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : [NON-XML-CHAR-0x1B][1mTrain all methods[NON-XML-CHAR-0x1B][0m
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.015080     1.7324   [    -9.3187     7.5304 ]
                         :   myvar2:  -0.034779     1.1155   [    -3.7067     4.0291 ]
                         :     var3: -0.0079573     1.0713   [    -5.0508     4.3301 ]
                         :     var4:    0.14942     1.2570   [    -5.8296     5.0307 ]
                         : -----------------------------------------------------------
                         : Preparing the Decorrelation transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.13942     1.0000   [    -4.8534     4.6721 ]
                         :   myvar2:  -0.057698     1.0000   [    -3.3267     3.6525 ]
                         :     var3:   -0.13281     1.0000   [    -3.8074     4.2782 ]
                         :     var4:    0.34988     1.0000   [    -3.6552     3.4484 ]
                         : -----------------------------------------------------------
                         : Preparing the Principle Component (PCA) transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1: -0.0053192     2.2925   [    -11.971     9.3295 ]
                         :   myvar2:   0.026354     1.1267   [    -4.0519     3.7451 ]
                         :     var3:  -0.011734    0.57939   [    -1.9673     2.1984 ]
                         :     var4: -0.0074322    0.33559   [    -1.0773     1.0734 ]
                         : -----------------------------------------------------------
                         : Preparing the Gaussian transformation...
                         : Preparing the Decorrelation transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:  -0.036773     1.0000   [    -3.0875     8.2962 ]
                         :   myvar2: -0.0064547     1.0000   [    -3.2228     5.7588 ]
                         :     var3: -0.0048158     1.0000   [    -3.1042     7.1073 ]
                         :     var4:   0.069766     1.0000   [    -3.5018     6.0169 ]
                         : -----------------------------------------------------------
                         : Ranking input variables (method unspecific)...
IdTransformation         : Ranking result (top variable is best ranked)
                         : -------------------------------------
                         : Rank : Variable     : Separation
                         : -------------------------------------
                         :    1 : Variable 4   : 2.725e-01
                         :    2 : Variable 3   : 1.478e-01
                         :    3 : myvar1       : 9.376e-02
                         :    4 : Expression 2 : 3.146e-02
                         : -------------------------------------
Factory                  : Train method: Cuts for Classification
                         : 
FitterBase               : <MCFitter> Sampling, please be patient ...
0%, time left: unknown
7%, time left: 4 sec
13%, time left: 4 sec
19%, time left: 4 sec
25%, time left: 3 sec
32%, time left: 3 sec
38%, time left: 3 sec
44%, time left: 2 sec
50%, time left: 2 sec
57%, time left: 2 sec
63%, time left: 1 sec
69%, time left: 1 sec
75%, time left: 1 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time: 5.06 sec                           
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.1
                         : Corresponding background efficiency       : 0.00526008
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -1.66754 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=   0.396795
                         : Cut[ 2]:   -4.09811 <   var3 <=      1e+30
                         : Cut[ 3]:    1.92503 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.2
                         : Corresponding background efficiency       : 0.0190872
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -3.45493 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.19089
                         : Cut[ 2]:   -4.77664 <   var3 <=      1e+30
                         : Cut[ 3]:    1.70772 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.3
                         : Corresponding background efficiency       : 0.0386523
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:    -4.7772 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=   0.977644
                         : Cut[ 2]:   -1.79692 <   var3 <=      1e+30
                         : Cut[ 3]:    1.14937 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.4
                         : Corresponding background efficiency       : 0.0623442
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -3.79225 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    1.93205
                         : Cut[ 2]:  -0.909042 <   var3 <=      1e+30
                         : Cut[ 3]:    1.06298 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.5
                         : Corresponding background efficiency       : 0.109266
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -8.59467 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    1.54856
                         : Cut[ 2]:  -0.902111 <   var3 <=      1e+30
                         : Cut[ 3]:   0.689079 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.6
                         : Corresponding background efficiency       : 0.144641
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -3.38024 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.36249
                         : Cut[ 2]:   -5.12445 <   var3 <=      1e+30
                         : Cut[ 3]:     0.5184 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.7
                         : Corresponding background efficiency       : 0.241452
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -7.91418 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.08155
                         : Cut[ 2]:   -3.35271 <   var3 <=      1e+30
                         : Cut[ 3]:   0.214767 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.8
                         : Corresponding background efficiency       : 0.361263
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -1.95767 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.98091
                         : Cut[ 2]:   -3.70204 <   var3 <=      1e+30
                         : Cut[ 3]:  -0.118037 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.9
                         : Corresponding background efficiency       : 0.599748
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:    -7.0228 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.97185
                         : Cut[ 2]:   -1.38278 <   var3 <=      1e+30
                         : Cut[ 3]:  -0.728796 <   var4 <=      1e+30
                         : ------------------------------------------
                         : Elapsed time for training with 2000 events: 5.06 sec         
Cuts                     : [dataset] : Evaluation of Cuts on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.000611 sec       
94%, time left: 0 sec
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Cuts.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Cuts.class.C[NON-XML-CHAR-0x1B][0m
                         : 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.13942     1.0000   [    -4.8534     4.6721 ]
                         :   myvar2:  -0.057698     1.0000   [    -3.3267     3.6525 ]
                         :     var3:   -0.13281     1.0000   [    -3.8074     4.2782 ]
                         :     var4:    0.34988     1.0000   [    -3.6552     3.4484 ]
                         : -----------------------------------------------------------
TFHandler_CutsD          : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.13942     1.0000   [    -4.8534     4.6721 ]
                         :   myvar2:  -0.057698     1.0000   [    -3.3267     3.6525 ]
                         :     var3:   -0.13281     1.0000   [    -3.8074     4.2782 ]
                         :     var4:    0.34988     1.0000   [    -3.6552     3.4484 ]
                         : -----------------------------------------------------------
FitterBase               : <MCFitter> Sampling, please be patient ...
0%, time left: unknown
7%, time left: 3 sec
13%, time left: 3 sec
19%, time left: 3 sec
25%, time left: 2 sec
32%, time left: 2 sec
38%, time left: 2 sec
44%, time left: 2 sec
50%, time left: 1 sec
57%, time left: 1 sec
63%, time left: 1 sec
69%, time left: 1 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time: 3.9 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.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=  -0.293952
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    2.82497
                         : Cut[ 2]:  -0.412575 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    1.23915 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.2
                         : Corresponding background efficiency       : 0.000958133
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=   0.301143
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    2.55858
                         : Cut[ 2]:  -0.783016 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    1.22918 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.3
                         : Corresponding background efficiency       : 0.0048755
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    4.19975
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=   -0.15415
                         : Cut[ 2]:   -3.60378 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.820318 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.4
                         : Corresponding background efficiency       : 0.0119257
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=     4.6873
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    1.70715
                         : Cut[ 2]:   -1.69799 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    1.15831 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.5
                         : Corresponding background efficiency       : 0.0205391
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    4.07561
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    1.10156
                         : Cut[ 2]:   -2.34168 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.941765 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.6
                         : Corresponding background efficiency       : 0.0312968
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=     4.0724
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    3.47532
                         : Cut[ 2]:   -2.52894 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    0.88763 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.7
                         : Corresponding background efficiency       : 0.0728951
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    3.01933
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    2.63051
                         : Cut[ 2]:   -2.53907 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.670062 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.8
                         : Corresponding background efficiency       : 0.132385
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    2.83282
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    3.63856
                         : Cut[ 2]:   -2.32922 <  -0%, time left: unknown
    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.450885 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.9
                         : Corresponding background efficiency       : 0.283046
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.27%, time left: 0 sec
0511*[var3] -    0.81946*[var4] <=    3.83336
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    3.24452
                         : Cut[ 2]:   -3.17726 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:  0.0796929 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Elapsed time for training with 2000 events: 3.91 sec         
CutsD                    : [dataset] : Evaluation of CutsD on training sample (2000 events)
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.00343 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_CutsD.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_CutsD.class.C[NON-XML-CHAR-0x1B][0m
                         : TMVA.root:/dataset/Method_Cuts/CutsD
Factory                  : Training finished
                         : 
Factory                  : Train method: Likelihood for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ Likelihood ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance optimisation:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
                         : Filling reference histograms
                         : Building PDF out of reference histograms
                         : Elapsed time for training with 2000 events: 0.0237 sec         
Likelihood               : [dataset] : Evaluation of Likelihood on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.00501 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Likelihood.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Likelihood.class.C[NON-XML-CHAR-0x1B][0m
                         : 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.0053192     2.2925   [    -11.971     9.3295 ]
                         :   myvar2:   0.026354     1.1267   [    -4.0519     3.7451 ]
                         :     var3:  -0.011734    0.57939   [    -1.9673     2.1984 ]
                         :     var4: -0.0074322    0.33559   [    -1.0773     1.0734 ]
                         : -----------------------------------------------------------
                         : Filling reference histograms
                         : Building PDF out of reference histograms
                         : Elapsed time for training with 2000 events: 0.0337 sec         
LikelihoodPCA            : [dataset] : Evaluation of LikelihoodPCA on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.0123 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LikelihoodPCA.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LikelihoodPCA.class.C[NON-XML-CHAR-0x1B][0m
                         : TMVA.root:/dataset/Method_Likelihood/LikelihoodPCA
Factory                  : Training finished
                         : 
Factory                  : Train method: PDERS for Classification
                         : 
                         : Elapsed time for training with 2000 events: 0.00796 sec         
PDERS                    : [dataset] : Evaluation of PDERS on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.345 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDERS.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDERS.class.C[NON-XML-CHAR-0x1B][0m
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
0%, time left: unknown
7%, time left: 5 sec
                         : Elapsed time: 0.787 sec                                 
                         : Elapsed time for training with 2000 events: 0.849 sec         
PDEFoam                  : [dataset] : Evaluation of PDEFoam on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.0333 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDEFoam.weights.xml[NON-XML-CHAR-0x1B][0m
                         : writing foam DiscrFoam to file
                         : Foams written to file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDEFoam.weights_foams.root[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDEFoam.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: KNN for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ KNN ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options: [NON-XML-CHAR-0x1B][0m
                         : 
                         : 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.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Additional configuration options: [NON-XML-CHAR-0x1B][0m
                         : 
                         : 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>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
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.00834 sec         
KNN                      : [dataset] : Evaluation of KNN on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.121 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_KNN.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_KNN.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: LD for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ LD ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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.)
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance optimisation:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options:[NON-XML-CHAR-0x1B][0m
                         : 
                         : <None>
                         : 
                         : <Suppress this message by specifying "!H" in the booking option>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
LD                       : Results for LD coefficients:
                         : -----------------------
                         : Variable:  Coefficient:
                         : -----------------------
                         :   myvar1:       -0.333
                         :   myvar2:       -0.085
                         :     var3:       -0.171
                         :     var4:       +0.746
                         : (offset):       -0.060
                         : -----------------------
                         : Elapsed time for training with 2000 events: 0.00242 sec         
LD                       : [dataset] : Evaluation of LD on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.00198 sec       
                         : <CreateMVAPdfs> Separation from histogram (PDF): 0.560 (0.000)
                         : Dataset[dataset] : Evaluation of LD on training sample
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LD.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LD.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: FDA_GA for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ FDA_GA ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance optimisation:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
FitterBase               : <GeneticFitter> Optimisation, please be patient ... (inaccurate progress timing for GA)
0%, time left: unknown
10%, time left: 1 sec
20%, time left: 1 sec
30%, time left: 0 sec
40%, time left: 0 sec
50%, time left: 0 sec
60%, time left: 0 sec
70%, time left: 0 sec
80%, time left: 0 sec
90%, time left: 6 sec
                         : Elapsed time: 60.6 sec                            
100%, time left: 0 sec
FDA_GA                   : Results for parameter fit using "GA" fitter:
                         : -----------------------
                         : Parameter:  Fit result:
                         : -----------------------
                         :    Par(0):    0.493644
                         :    Par(1):   -0.195107
                         :    Par(2):           0
                         :    Par(3):           0
                         :    Par(4):    0.389774
                         : -----------------------
                         : Discriminator expression: "(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3"
                         : Value of estimator at minimum: 0.302763
                         : Elapsed time for training with 2000 events: 60.7 sec         
FDA_GA                   : [dataset] : Evaluation of FDA_GA on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.000899 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_FDA_GA.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_FDA_GA.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: MLPBNN for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ MLPBNN ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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). 
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance optimisation:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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).
                         : 
                         : [NON-XML-CHAR-0x1B][1mOvertraining: [NON-XML-CHAR-0x1B][0monly 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.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options:[NON-XML-CHAR-0x1B][0m
                         : 
                         : 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
              ...
The rest of the test output was removed since it exceeds the threshold of 64000 bytes.