Logo ROOT  

Reference Guide
TMVA_CNN_Classification.C File Reference
Tutorials » TMVA tutorials

Detailed Description

View in nbviewer Open in SWAN TMVA Classification Example Using a Convolutional Neural Network

This is an example of using a CNN in TMVA. We do classification using a toy image data set that is generated when running the example macro

Running with nthreads = 16
DataSetInfo : [dataset] : Added class "Signal"
: Add Tree sig_tree of type Signal with 5000 events
DataSetInfo : [dataset] : Added class "Background"
: Add Tree bkg_tree of type Background with 5000 events
Factory : Booking method: ␛[1mBDT␛[0m
:
: Building event vectors for type 2 Signal
: Dataset[dataset] : create input formulas for tree sig_tree
: Using variable vars[0] from array expression vars of size 256
: Building event vectors for type 2 Background
: Dataset[dataset] : create input formulas for tree bkg_tree
: Using variable vars[0] from array expression vars of size 256
DataSetFactory : [dataset] : Number of events in input trees
:
:
: Number of training and testing events
: ---------------------------------------------------------------------------
: Signal -- training events : 4000
: Signal -- testing events : 1000
: Signal -- training and testing events: 5000
: Background -- training events : 4000
: Background -- testing events : 1000
: Background -- training and testing events: 5000
:
Factory : Booking method: ␛[1mTMVA_DNN_CPU␛[0m
:
: Parsing option string:
: ... "!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=None:WeightInitialization=XAVIER:Layout=DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,DENSE|1|LINEAR:TrainingStrategy=LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,MaxEpochs=20,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.: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=None:WeightInitialization=XAVIER:Layout=DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,DENSE|1|LINEAR:TrainingStrategy=LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,MaxEpochs=20,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.:Architecture=CPU"
: The following options are set:
: - By User:
: V: "True" [Verbose output (short form of "VerbosityLevel" below - overrides the latter one)]
: VarTransform: "None" [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: "DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,DENSE|1|LINEAR" [Layout of the network.]
: ErrorStrategy: "CROSSENTROPY" [Loss function: Mean squared error (regression) or cross entropy (binary classification).]
: WeightInitialization: "XAVIER" [Weight initialization strategy]
: Architecture: "CPU" [Which architecture to perform the training on.]
: TrainingStrategy: "LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,MaxEpochs=20,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0." [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%)]
: Will now use the CPU architecture with BLAS and IMT support !
Factory : Booking method: ␛[1mTMVA_CNN_CPU␛[0m
:
: Parsing option string:
: ... "!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=None:WeightInitialization=XAVIER:InputLayout=1|16|16:Layout=CONV|10|3|3|1|1|1|1|RELU,BNORM,CONV|10|3|3|1|1|1|1|RELU,MAXPOOL|2|2|1|1,RESHAPE|FLAT,DENSE|100|RELU,DENSE|1|LINEAR:TrainingStrategy=LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,MaxEpochs=20,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0: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=None:WeightInitialization=XAVIER:InputLayout=1|16|16:Layout=CONV|10|3|3|1|1|1|1|RELU,BNORM,CONV|10|3|3|1|1|1|1|RELU,MAXPOOL|2|2|1|1,RESHAPE|FLAT,DENSE|100|RELU,DENSE|1|LINEAR:TrainingStrategy=LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,MaxEpochs=20,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0:Architecture=CPU"
: The following options are set:
: - By User:
: V: "True" [Verbose output (short form of "VerbosityLevel" below - overrides the latter one)]
: VarTransform: "None" [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]
: InputLayout: "1|16|16" [The Layout of the input]
: Layout: "CONV|10|3|3|1|1|1|1|RELU,BNORM,CONV|10|3|3|1|1|1|1|RELU,MAXPOOL|2|2|1|1,RESHAPE|FLAT,DENSE|100|RELU,DENSE|1|LINEAR" [Layout of the network.]
: ErrorStrategy: "CROSSENTROPY" [Loss function: Mean squared error (regression) or cross entropy (binary classification).]
: WeightInitialization: "XAVIER" [Weight initialization strategy]
: Architecture: "CPU" [Which architecture to perform the training on.]
: TrainingStrategy: "LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,MaxEpochs=20,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0" [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)]
: 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%)]
: Will now use the CPU architecture with BLAS and IMT support !
Factory : ␛[1mTrain all methods␛[0m
Factory : Train method: BDT for Classification
:
BDT : #events: (reweighted) sig: 4000 bkg: 4000
: #events: (unweighted) sig: 4000 bkg: 4000
: Training 400 Decision Trees ... patience please
: Elapsed time for training with 8000 events: 6.41 sec
BDT : [dataset] : Evaluation of BDT on training sample (8000 events)
: Elapsed time for evaluation of 8000 events: 0.184 sec
: Creating xml weight file: ␛[0;36mdataset/weights/TMVA_CNN_Classification_BDT.weights.xml␛[0m
: Creating standalone class: ␛[0;36mdataset/weights/TMVA_CNN_Classification_BDT.class.C␛[0m
: TMVA_CNN_ClassificationOutput.root:/dataset/Method_BDT/BDT
Factory : Training finished
:
Factory : Train method: TMVA_DNN_CPU for Classification
:
: Start of deep neural network training on CPU using MT, nthreads = 16
:
: ***** Deep Learning Network *****
DEEP NEURAL NETWORK: Depth = 8 Input = ( 1, 1, 256 ) Batch size = 100 Loss function = C
Layer 0 DENSE Layer: ( Input = 256 , Width = 100 ) Output = ( 1 , 100 , 100 ) Activation Function = Relu
Layer 1 BATCH NORM Layer: Input/Output = ( 100 , 100 , 1 ) Norm dim = 100 axis = -1
Layer 2 DENSE Layer: ( Input = 100 , Width = 100 ) Output = ( 1 , 100 , 100 ) Activation Function = Relu
Layer 3 BATCH NORM Layer: Input/Output = ( 100 , 100 , 1 ) Norm dim = 100 axis = -1
Layer 4 DENSE Layer: ( Input = 100 , Width = 100 ) Output = ( 1 , 100 , 100 ) Activation Function = Relu
Layer 5 BATCH NORM Layer: Input/Output = ( 100 , 100 , 1 ) Norm dim = 100 axis = -1
Layer 6 DENSE Layer: ( Input = 100 , Width = 100 ) Output = ( 1 , 100 , 100 ) Activation Function = Relu
Layer 7 DENSE Layer: ( Input = 100 , Width = 1 ) Output = ( 1 , 100 , 1 ) Activation Function = Identity
: Using 6400 events for training and 1600 for testing
: Compute initial loss on the validation data
: Training phase 1 of 1: Optimizer ADAM (beta1=0.9,beta2=0.999,eps=1e-07) Learning rate = 0.001 regularization 0 minimum error = inf
: --------------------------------------------------------------
: 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.764165 0.804883 0.970004 0.0817397 7205.06 0
: 2 Minimum Test error found - save the configuration
: 2 | 0.587023 0.721052 0.978964 0.0859798 7166.98 0
: 3 Minimum Test error found - save the configuration
: 3 | 0.48048 0.623492 0.978669 0.082079 7138.16 0
: 4 Minimum Test error found - save the configuration
: 4 | 0.413928 0.574944 0.972145 0.081604 7186.64 0
: 5 | 0.369913 0.707697 0.974461 0.0808876 7162.26 1
: 6 Minimum Test error found - save the configuration
: 6 | 0.341224 0.478256 0.969659 0.081876 7208.97 0
: 7 Minimum Test error found - save the configuration
: 7 | 0.307892 0.472754 0.968482 0.0816273 7216.52 0
: 8 | 0.296916 0.488932 0.971024 0.0808223 7189.38 1
: 9 | 0.284388 0.513776 0.973601 0.0817725 7176.27 2
: 10 | 0.255926 0.511897 0.969136 0.080793 7204.42 3
: 11 | 0.256289 0.475008 0.973702 0.0810995 7170.04 4
: 12 | 0.241834 0.56309 0.987734 0.0808275 7056.96 5
: 13 | 0.216787 0.58009 1.02429 0.0808227 6783.49 6
:
: Elapsed time for training with 8000 events: 12.8 sec
: Evaluate deep neural network on CPU using batches with size = 100
:
TMVA_DNN_CPU : [dataset] : Evaluation of TMVA_DNN_CPU on training sample (8000 events)
: Elapsed time for evaluation of 8000 events: 0.402 sec
: Creating xml weight file: ␛[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_DNN_CPU.weights.xml␛[0m
: Creating standalone class: ␛[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_DNN_CPU.class.C␛[0m
Factory : Training finished
:
Factory : Train method: TMVA_CNN_CPU for Classification
:
: Start of deep neural network training on CPU using MT, nthreads = 16
:
: ***** Deep Learning Network *****
DEEP NEURAL NETWORK: Depth = 7 Input = ( 1, 16, 16 ) Batch size = 100 Loss function = C
Layer 0 CONV LAYER: ( W = 16 , H = 16 , D = 10 ) Filter ( W = 3 , H = 3 ) Output = ( 100 , 10 , 10 , 256 ) Activation Function = Relu
Layer 1 BATCH NORM Layer: Input/Output = ( 10 , 256 , 100 ) Norm dim = 10 axis = 1
Layer 2 CONV LAYER: ( W = 16 , H = 16 , D = 10 ) Filter ( W = 3 , H = 3 ) Output = ( 100 , 10 , 10 , 256 ) Activation Function = Relu
Layer 3 POOL Layer: ( W = 15 , H = 15 , D = 10 ) Filter ( W = 2 , H = 2 ) Output = ( 100 , 10 , 10 , 225 )
Layer 4 RESHAPE Layer Input = ( 10 , 15 , 15 ) Output = ( 1 , 100 , 2250 )
Layer 5 DENSE Layer: ( Input = 2250 , Width = 100 ) Output = ( 1 , 100 , 100 ) Activation Function = Relu
Layer 6 DENSE Layer: ( Input = 100 , Width = 1 ) Output = ( 1 , 100 , 1 ) Activation Function = Identity
: Using 6400 events for training and 1600 for testing
: Compute initial loss on the validation data
: Training phase 1 of 1: Optimizer ADAM (beta1=0.9,beta2=0.999,eps=1e-07) Learning rate = 0.001 regularization 0 minimum error = inf
: --------------------------------------------------------------
: 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.880715 0.654781 6.56798 0.50596 1055.75 0
: 2 Minimum Test error found - save the configuration
: 2 | 0.5888 0.542195 6.61658 0.508628 1047.81 0
: 3 Minimum Test error found - save the configuration
: 3 | 0.479711 0.478808 6.62242 0.521013 1048.94 0
: 4 Minimum Test error found - save the configuration
: 4 | 0.449541 0.425081 6.67876 0.518078 1038.85 0
: 5 | 0.402947 0.476722 6.62993 0.516162 1046.82 1
: 6 | 0.399293 0.444414 6.6716 0.524761 1041.19 2
: 7 Minimum Test error found - save the configuration
: 7 | 0.393605 0.419727 6.67033 0.519914 1040.58 0
: 8 Minimum Test error found - save the configuration
: 8 | 0.374307 0.389117 6.67132 0.528896 1041.93 0
: 9 Minimum Test error found - save the configuration
: 9 | 0.345162 0.381626 6.70533 0.518397 1034.44 0
: 10 | 0.375481 0.475314 6.65496 0.514392 1042.25 1
: 11 | 0.339019 0.391698 6.82521 0.51228 1013.79 2
: 12 | 0.330023 0.442089 7.31129 0.511916 941.263 3
: 13 Minimum Test error found - save the configuration
: 13 | 0.313905 0.37102 7.62979 0.522777 900.519 0
: 14 | 0.307148 0.389217 7.53395 0.512511 911.494 1
: 15 | 0.315008 0.394759 7.42111 0.511237 926.211 2
: 16 | 0.326447 0.375951 7.46949 0.525684 921.685 3
: 17 | 0.318361 0.393118 7.44958 0.515049 922.918 4
: 18 | 0.289545 0.388169 7.44576 0.509831 922.731 5
: 19 | 0.291238 0.395734 7.46016 0.517084 921.782 6
:
: Elapsed time for training with 8000 events: 134 sec
: Evaluate deep neural network on CPU using batches with size = 100
:
TMVA_CNN_CPU : [dataset] : Evaluation of TMVA_CNN_CPU on training sample (8000 events)
: Elapsed time for evaluation of 8000 events: 2.57 sec
: Creating xml weight file: ␛[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_CNN_CPU.weights.xml␛[0m
: Creating standalone class: ␛[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_CNN_CPU.class.C␛[0m
Factory : Training finished
:
: Ranking input variables (method specific)...
BDT : Ranking result (top variable is best ranked)
: --------------------------------------
: Rank : Variable : Variable Importance
: --------------------------------------
: 1 : vars : 1.114e-02
: 2 : vars : 1.068e-02
: 3 : vars : 1.046e-02
: 4 : vars : 1.034e-02
: 5 : vars : 1.026e-02
: 6 : vars : 1.023e-02
: 7 : vars : 9.767e-03
: 8 : vars : 9.465e-03
: 9 : vars : 9.241e-03
: 10 : vars : 9.181e-03
: 11 : vars : 9.058e-03
: 12 : vars : 8.970e-03
: 13 : vars : 8.872e-03
: 14 : vars : 8.871e-03
: 15 : vars : 8.793e-03
: 16 : vars : 8.735e-03
: 17 : vars : 8.637e-03
: 18 : vars : 8.615e-03
: 19 : vars : 8.523e-03
: 20 : vars : 8.469e-03
: 21 : vars : 8.206e-03
: 22 : vars : 8.206e-03
: 23 : vars : 7.991e-03
: 24 : vars : 7.900e-03
: 25 : vars : 7.853e-03
: 26 : vars : 7.816e-03
: 27 : vars : 7.736e-03
: 28 : vars : 7.615e-03
: 29 : vars : 7.600e-03
: 30 : vars : 7.598e-03
: 31 : vars : 7.571e-03
: 32 : vars : 7.565e-03
: 33 : vars : 7.531e-03
: 34 : vars : 7.406e-03
: 35 : vars : 7.358e-03
: 36 : vars : 7.350e-03
: 37 : vars : 7.163e-03
: 38 : vars : 7.146e-03
: 39 : vars : 7.117e-03
: 40 : vars : 7.101e-03
: 41 : vars : 7.068e-03
: 42 : vars : 7.019e-03
: 43 : vars : 6.854e-03
: 44 : vars : 6.812e-03
: 45 : vars : 6.608e-03
: 46 : vars : 6.548e-03
: 47 : vars : 6.541e-03
: 48 : vars : 6.523e-03
: 49 : vars : 6.516e-03
: 50 : vars : 6.502e-03
: 51 : vars : 6.489e-03
: 52 : vars : 6.450e-03
: 53 : vars : 6.162e-03
: 54 : vars : 6.161e-03
: 55 : vars : 6.142e-03
: 56 : vars : 6.138e-03
: 57 : vars : 6.132e-03
: 58 : vars : 6.123e-03
: 59 : vars : 6.115e-03
: 60 : vars : 6.011e-03
: 61 : vars : 5.955e-03
: 62 : vars : 5.906e-03
: 63 : vars : 5.905e-03
: 64 : vars : 5.890e-03
: 65 : vars : 5.851e-03
: 66 : vars : 5.812e-03
: 67 : vars : 5.746e-03
: 68 : vars : 5.714e-03
: 69 : vars : 5.608e-03
: 70 : vars : 5.605e-03
: 71 : vars : 5.587e-03
: 72 : vars : 5.579e-03
: 73 : vars : 5.569e-03
: 74 : vars : 5.540e-03
: 75 : vars : 5.536e-03
: 76 : vars : 5.429e-03
: 77 : vars : 5.353e-03
: 78 : vars : 5.316e-03
: 79 : vars : 5.309e-03
: 80 : vars : 5.223e-03
: 81 : vars : 5.080e-03
: 82 : vars : 5.047e-03
: 83 : vars : 4.961e-03
: 84 : vars : 4.917e-03
: 85 : vars : 4.881e-03
: 86 : vars : 4.874e-03
: 87 : vars : 4.871e-03
: 88 : vars : 4.772e-03
: 89 : vars : 4.728e-03
: 90 : vars : 4.723e-03
: 91 : vars : 4.681e-03
: 92 : vars : 4.663e-03
: 93 : vars : 4.628e-03
: 94 : vars : 4.592e-03
: 95 : vars : 4.558e-03
: 96 : vars : 4.552e-03
: 97 : vars : 4.534e-03
: 98 : vars : 4.528e-03
: 99 : vars : 4.523e-03
: 100 : vars : 4.518e-03
: 101 : vars : 4.483e-03
: 102 : vars : 4.452e-03
: 103 : vars : 4.390e-03
: 104 : vars : 4.385e-03
: 105 : vars : 4.359e-03
: 106 : vars : 4.344e-03
: 107 : vars : 4.333e-03
: 108 : vars : 4.313e-03
: 109 : vars : 4.238e-03
: 110 : vars : 4.220e-03
: 111 : vars : 4.143e-03
: 112 : vars : 4.140e-03
: 113 : vars : 4.072e-03
: 114 : vars : 4.048e-03
: 115 : vars : 4.045e-03
: 116 : vars : 4.024e-03
: 117 : vars : 4.011e-03
: 118 : vars : 4.007e-03
: 119 : vars : 3.967e-03
: 120 : vars : 3.930e-03
: 121 : vars : 3.904e-03
: 122 : vars : 3.890e-03
: 123 : vars : 3.841e-03
: 124 : vars : 3.818e-03
: 125 : vars : 3.804e-03
: 126 : vars : 3.783e-03
: 127 : vars : 3.609e-03
: 128 : vars : 3.567e-03
: 129 : vars : 3.560e-03
: 130 : vars : 3.555e-03
: 131 : vars : 3.530e-03
: 132 : vars : 3.511e-03
: 133 : vars : 3.510e-03
: 134 : vars : 3.507e-03
: 135 : vars : 3.505e-03
: 136 : vars : 3.500e-03
: 137 : vars : 3.469e-03
: 138 : vars : 3.365e-03
: 139 : vars : 3.337e-03
: 140 : vars : 3.336e-03
: 141 : vars : 3.319e-03
: 142 : vars : 3.318e-03
: 143 : vars : 3.316e-03
: 144 : vars : 3.302e-03
: 145 : vars : 3.209e-03
: 146 : vars : 3.182e-03
: 147 : vars : 3.129e-03
: 148 : vars : 3.097e-03
: 149 : vars : 3.071e-03
: 150 : vars : 3.059e-03
: 151 : vars : 3.030e-03
: 152 : vars : 2.988e-03
: 153 : vars : 2.956e-03
: 154 : vars : 2.926e-03
: 155 : vars : 2.872e-03
: 156 : vars : 2.810e-03
: 157 : vars : 2.796e-03
: 158 : vars : 2.781e-03
: 159 : vars : 2.775e-03
: 160 : vars : 2.730e-03
: 161 : vars : 2.728e-03
: 162 : vars : 2.724e-03
: 163 : vars : 2.722e-03
: 164 : vars : 2.689e-03
: 165 : vars : 2.665e-03
: 166 : vars : 2.621e-03
: 167 : vars : 2.565e-03
: 168 : vars : 2.556e-03
: 169 : vars : 2.533e-03
: 170 : vars : 2.508e-03
: 171 : vars : 2.496e-03
: 172 : vars : 2.485e-03
: 173 : vars : 2.471e-03
: 174 : vars : 2.445e-03
: 175 : vars : 2.397e-03
: 176 : vars : 2.373e-03
: 177 : vars : 2.350e-03
: 178 : vars : 2.335e-03
: 179 : vars : 2.282e-03
: 180 : vars : 2.277e-03
: 181 : vars : 2.233e-03
: 182 : vars : 2.231e-03
: 183 : vars : 2.223e-03
: 184 : vars : 2.194e-03
: 185 : vars : 2.181e-03
: 186 : vars : 2.155e-03
: 187 : vars : 2.118e-03
: 188 : vars : 2.090e-03
: 189 : vars : 2.078e-03
: 190 : vars : 2.058e-03
: 191 : vars : 2.033e-03
: 192 : vars : 2.025e-03
: 193 : vars : 2.010e-03
: 194 : vars : 2.006e-03
: 195 : vars : 1.955e-03
: 196 : vars : 1.941e-03
: 197 : vars : 1.838e-03
: 198 : vars : 1.822e-03
: 199 : vars : 1.811e-03
: 200 : vars : 1.797e-03
: 201 : vars : 1.782e-03
: 202 : vars : 1.761e-03
: 203 : vars : 1.669e-03
: 204 : vars : 1.636e-03
: 205 : vars : 1.565e-03
: 206 : vars : 1.486e-03
: 207 : vars : 1.420e-03
: 208 : vars : 1.389e-03
: 209 : vars : 1.355e-03
: 210 : vars : 9.952e-04
: 211 : vars : 8.570e-04
: 212 : vars : 4.714e-04
: 213 : vars : 0.000e+00
: 214 : vars : 0.000e+00
: 215 : vars : 0.000e+00
: 216 : vars : 0.000e+00
: 217 : vars : 0.000e+00
: 218 : vars : 0.000e+00
: 219 : vars : 0.000e+00
: 220 : vars : 0.000e+00
: 221 : vars : 0.000e+00
: 222 : vars : 0.000e+00
: 223 : vars : 0.000e+00
: 224 : vars : 0.000e+00
: 225 : vars : 0.000e+00
: 226 : vars : 0.000e+00
: 227 : vars : 0.000e+00
: 228 : vars : 0.000e+00
: 229 : vars : 0.000e+00
: 230 : vars : 0.000e+00
: 231 : vars : 0.000e+00
: 232 : vars : 0.000e+00
: 233 : vars : 0.000e+00
: 234 : vars : 0.000e+00
: 235 : vars : 0.000e+00
: 236 : vars : 0.000e+00
: 237 : vars : 0.000e+00
: 238 : vars : 0.000e+00
: 239 : vars : 0.000e+00
: 240 : vars : 0.000e+00
: 241 : vars : 0.000e+00
: 242 : vars : 0.000e+00
: 243 : vars : 0.000e+00
: 244 : vars : 0.000e+00
: 245 : vars : 0.000e+00
: 246 : vars : 0.000e+00
: 247 : vars : 0.000e+00
: 248 : vars : 0.000e+00
: 249 : vars : 0.000e+00
: 250 : vars : 0.000e+00
: 251 : vars : 0.000e+00
: 252 : vars : 0.000e+00
: 253 : vars : 0.000e+00
: 254 : vars : 0.000e+00
: 255 : vars : 0.000e+00
: 256 : vars : 0.000e+00
: --------------------------------------
: No variable ranking supplied by classifier: TMVA_DNN_CPU
: No variable ranking supplied by classifier: TMVA_CNN_CPU
TH1.Print Name = TrainingHistory_TMVA_DNN_CPU_trainingError, Entries= 0, Total sum= 4.81677
TH1.Print Name = TrainingHistory_TMVA_DNN_CPU_valError, Entries= 0, Total sum= 7.51587
TH1.Print Name = TrainingHistory_TMVA_CNN_CPU_trainingError, Entries= 0, Total sum= 7.52026
TH1.Print Name = TrainingHistory_TMVA_CNN_CPU_valError, Entries= 0, Total sum= 8.22954
Factory : === Destroy and recreate all methods via weight files for testing ===
:
: Reading weight file: ␛[0;36mdataset/weights/TMVA_CNN_Classification_BDT.weights.xml␛[0m
: Reading weight file: ␛[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_DNN_CPU.weights.xml␛[0m
: Reading weight file: ␛[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_CNN_CPU.weights.xml␛[0m
Factory : ␛[1mTest all methods␛[0m
Factory : Test method: BDT for Classification performance
:
BDT : [dataset] : Evaluation of BDT on testing sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.0426 sec
Factory : Test method: TMVA_DNN_CPU for Classification performance
:
: Evaluate deep neural network on CPU using batches with size = 1000
:
TMVA_DNN_CPU : [dataset] : Evaluation of TMVA_DNN_CPU on testing sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.0885 sec
Factory : Test method: TMVA_CNN_CPU for Classification performance
:
: Evaluate deep neural network on CPU using batches with size = 1000
:
TMVA_CNN_CPU : [dataset] : Evaluation of TMVA_CNN_CPU on testing sample (2000 events)
: Elapsed time for evaluation of 2000 events: 0.64 sec
Factory : ␛[1mEvaluate all methods␛[0m
Factory : Evaluate classifier: BDT
:
BDT : [dataset] : Loop over test events and fill histograms with classifier response...
:
: Dataset[dataset] : variable plots are not produces ! The number of variables is 256 , it is larger than 200
Factory : Evaluate classifier: TMVA_DNN_CPU
:
TMVA_DNN_CPU : [dataset] : Loop over test events and fill histograms with classifier response...
:
: Evaluate deep neural network on CPU using batches with size = 1000
:
: Dataset[dataset] : variable plots are not produces ! The number of variables is 256 , it is larger than 200
Factory : Evaluate classifier: TMVA_CNN_CPU
:
TMVA_CNN_CPU : [dataset] : Loop over test events and fill histograms with classifier response...
:
: Evaluate deep neural network on CPU using batches with size = 1000
:
: Dataset[dataset] : variable plots are not produces ! The number of variables is 256 , it is larger than 200
:
: Evaluation results ranked by best signal efficiency and purity (area)
: -------------------------------------------------------------------------------------------------------------------
: DataSet MVA
: Name: Method: ROC-integ
: dataset TMVA_CNN_CPU : 0.916
: dataset TMVA_DNN_CPU : 0.885
: dataset BDT : 0.839
: -------------------------------------------------------------------------------------------------------------------
:
: 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 TMVA_CNN_CPU : 0.325 (0.460) 0.742 (0.802) 0.933 (0.940)
: dataset TMVA_DNN_CPU : 0.315 (0.390) 0.663 (0.739) 0.873 (0.902)
: dataset BDT : 0.140 (0.305) 0.554 (0.662) 0.814 (0.862)
: -------------------------------------------------------------------------------------------------------------------
:
Dataset:dataset : Created tree 'TestTree' with 2000 events
:
Dataset:dataset : Created tree 'TrainTree' with 8000 events
:
Factory : ␛[1mThank you for using TMVA!␛[0m
: ␛[1mFor citation information, please visit: http://tmva.sf.net/citeTMVA.html␛[0m
/***
# TMVA Classification Example Using a Convolutional Neural Network
**/
/// Helper function to create input images data
/// we create a signal and background 2D histograms from 2d gaussians
/// with a location (means in X and Y) different for each event
/// The difference between signal and background is in the gaussian width.
/// The width for the bakground gaussian is slightly larger than the signal width by few % values
///
///
void MakeImagesTree(int n, int nh, int nw)
{
// image size (nh x nw)
const int ntot = nh * nw;
const TString fileOutName = TString::Format("images_data_%dx%d.root", nh, nw);
const int nRndmEvts = 10000; // number of events we use to fill each image
double delta_sigma = 0.1; // 5% difference in the sigma
double pixelNoise = 5;
double sX1 = 3;
double sY1 = 3;
double sX2 = sX1 + delta_sigma;
double sY2 = sY1 - delta_sigma;
auto h1 = new TH2D("h1", "h1", nh, 0, 10, nw, 0, 10);
auto h2 = new TH2D("h2", "h2", nh, 0, 10, nw, 0, 10);
auto f1 = new TF2("f1", "xygaus");
auto f2 = new TF2("f2", "xygaus");
TTree sgn("sig_tree", "signal_tree");
TTree bkg("bkg_tree", "bakground_tree");
TFile f(fileOutName, "RECREATE");
std::vector<float> x1(ntot);
std::vector<float> x2(ntot);
// create signal and background trees with a single branch
// an std::vector<float> of size nh x nw containing the image data
std::vector<float> *px1 = &x1;
std::vector<float> *px2 = &x2;
bkg.Branch("vars", "std::vector<float>", &px1);
sgn.Branch("vars", "std::vector<float>", &px2);
// std::cout << "create tree " << std::endl;
sgn.SetDirectory(&f);
bkg.SetDirectory(&f);
f1->SetParameters(1, 5, sX1, 5, sY1);
f2->SetParameters(1, 5, sX2, 5, sY2);
gRandom->SetSeed(0);
std::cout << "Filling ROOT tree " << std::endl;
for (int i = 0; i < n; ++i) {
if (i % 1000 == 0)
std::cout << "Generating image event ... " << i << std::endl;
h1->Reset();
h2->Reset();
// generate random means in range [3,7] to be not too much on the border
f1->SetParameter(1, gRandom->Uniform(3, 7));
f1->SetParameter(3, gRandom->Uniform(3, 7));
f2->SetParameter(1, gRandom->Uniform(3, 7));
f2->SetParameter(3, gRandom->Uniform(3, 7));
h1->FillRandom("f1", nRndmEvts);
h2->FillRandom("f2", nRndmEvts);
for (int k = 0; k < nh; ++k) {
for (int l = 0; l < nw; ++l) {
int m = k * nw + l;
// add some noise in each bin
x1[m] = h1->GetBinContent(k + 1, l + 1) + gRandom->Gaus(0, pixelNoise);
x2[m] = h2->GetBinContent(k + 1, l + 1) + gRandom->Gaus(0, pixelNoise);
}
}
sgn.Fill();
bkg.Fill();
}
sgn.Write();
bkg.Write();
Info("MakeImagesTree", "Signal and background tree with images data written to the file %s", f.GetName());
sgn.Print();
bkg.Print();
f.Close();
}
void TMVA_CNN_Classification(std::vector<bool> opt = {1, 1, 1, 1, 1})
{
bool useTMVACNN = (opt.size() > 0) ? opt[0] : false;
bool useKerasCNN = (opt.size() > 1) ? opt[1] : false;
bool useTMVADNN = (opt.size() > 2) ? opt[2] : false;
bool useTMVABDT = (opt.size() > 3) ? opt[3] : false;
bool usePyTorchCNN = (opt.size() > 4) ? opt[4] : false;
#ifndef R__HAS_TMVACPU
#ifndef R__HAS_TMVAGPU
Warning("TMVA_CNN_Classification",
"TMVA is not build with GPU or CPU multi-thread support. Cannot use TMVA Deep Learning for CNN");
useTMVACNN = false;
#endif
#endif
bool writeOutputFile = true;
int num_threads = 0; // use default threads
TMVA::Tools::Instance();
// do enable MT running
if (num_threads >= 0) {
ROOT::EnableImplicitMT(num_threads);
if (num_threads > 0) gSystem->Setenv("OMP_NUM_THREADS", TString::Format("%d",num_threads));
}
else
gSystem->Setenv("OMP_NUM_THREADS", "1");
std::cout << "Running with nthreads = " << ROOT::GetThreadPoolSize() << std::endl;
#ifdef R__HAS_PYMVA
gSystem->Setenv("KERAS_BACKEND", "tensorflow");
// for using Keras
TMVA::PyMethodBase::PyInitialize();
#else
useKerasCNN = false;
#endif
TFile *outputFile = nullptr;
if (writeOutputFile)
outputFile = TFile::Open("TMVA_CNN_ClassificationOutput.root", "RECREATE");
/***
## Create TMVA Factory
Create the Factory class. Later you can choose the methods
whose performance you'd like to investigate.
The factory is the major TMVA object you have to interact with. Here is the list of parameters you need to pass
- The first argument is the base of the name of all the output
weightfiles in the directory weight/ that will be created with the
method parameters
- The second argument is the output file for the training results
- The third argument is a string option defining some general configuration for the TMVA session.
For example all TMVA output can be suppressed by removing the "!" (not) in front of the "Silent" argument in the
option string
- note that we disable any pre-transformation of the input variables and we avoid computing correlations between
input variables
***/
TMVA::Factory factory(
"TMVA_CNN_Classification", outputFile,
"!V:ROC:!Silent:Color:AnalysisType=Classification:Transformations=None:!Correlations");
/***
## Declare DataLoader(s)
The next step is to declare the DataLoader class that deals with input variables
Define the input variables that shall be used for the MVA training
note that you may also use variable expressions, which can be parsed by TTree::Draw( "expression" )]
In this case the input data consists of an image of 16x16 pixels. Each single pixel is a branch in a ROOT TTree
**/
TMVA::DataLoader *loader = new TMVA::DataLoader("dataset");
/***
## Setup Dataset(s)
Define input data file and signal and background trees
**/
int imgSize = 16 * 16;
TString inputFileName = "images_data_16x16.root";
bool fileExist = !gSystem->AccessPathName(inputFileName);
// if file does not exists create it
if (!fileExist) {
MakeImagesTree(5000, 16, 16);
}
// TString inputFileName = "tmva_class_example.root";
auto inputFile = TFile::Open(inputFileName);
if (!inputFile) {
Error("TMVA_CNN_Classification", "Error opening input file %s - exit", inputFileName.Data());
return;
}
// --- Register the training and test trees
TTree *signalTree = (TTree *)inputFile->Get("sig_tree");
TTree *backgroundTree = (TTree *)inputFile->Get("bkg_tree");
int nEventsSig = signalTree->GetEntries();
int nEventsBkg = backgroundTree->GetEntries();
// 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
loader->AddSignalTree(signalTree, signalWeight);
loader->AddBackgroundTree(backgroundTree, backgroundWeight);
/// add event variables (image)
/// use new method (from ROOT 6.20 to add a variable array for all image data)
loader->AddVariablesArray("vars", imgSize);
// Set individual event weights (the variables must exist in the original TTree)
// for signal : factory->SetSignalWeightExpression ("weight1*weight2");
// for background: factory->SetBackgroundWeightExpression("weight1*weight2");
// loader->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 factory 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:
// loader->PrepareTrainingAndTestTree( mycut, "SplitMode=random:!V" );
// It is possible also to specify the number of training and testing events,
// note we disable the computation of the correlation matrix of the input variables
int nTrainSig = 0.8 * nEventsSig;
int nTrainBkg = 0.8 * nEventsBkg;
// build the string options for DataLoader::PrepareTrainingAndTestTree
TString prepareOptions = TString::Format(
"nTrain_Signal=%d:nTrain_Background=%d:SplitMode=Random:SplitSeed=100:NormMode=NumEvents:!V:!CalcCorrelations",
nTrainSig, nTrainBkg);
loader->PrepareTrainingAndTestTree(mycuts, mycutb, prepareOptions);
/***
DataSetInfo : [dataset] : Added class "Signal"
: Add Tree sig_tree of type Signal with 10000 events
DataSetInfo : [dataset] : Added class "Background"
: Add Tree bkg_tree of type Background with 10000 events
**/
// signalTree->Print();
/****
# Booking Methods
Here we book the TMVA methods. We book a Boosted Decision Tree method (BDT)
**/
// Boosted Decision Trees
if (useTMVABDT) {
factory.BookMethod(loader, TMVA::Types::kBDT, "BDT",
"!V:NTrees=400:MinNodeSize=2.5%:MaxDepth=2:BoostType=AdaBoost:AdaBoostBeta=0.5:"
"UseBaggedBoost:BaggedSampleFraction=0.5:SeparationType=GiniIndex:nCuts=20");
}
/**
#### Booking Deep Neural Network
Here we book the DNN of TMVA. See the example TMVA_Higgs_Classification.C for a detailed description of the
options
**/
if (useTMVADNN) {
TString layoutString(
"Layout=DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,DENSE|1|LINEAR");
// Training strategies
// one can catenate several training strings with different parameters (e.g. learning rates or regularizations
// parameters) The training string must be concatenates with the `|` delimiter
TString trainingString1("LearningRate=1e-3,Momentum=0.9,Repetitions=1,"
"ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,"
"MaxEpochs=20,WeightDecay=1e-4,Regularization=None,"
"Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.");
TString trainingStrategyString("TrainingStrategy=");
trainingStrategyString += trainingString1; // + "|" + trainingString2 + ....
// Build now the full DNN Option string
TString dnnOptions("!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=None:"
"WeightInitialization=XAVIER");
dnnOptions.Append(":");
dnnOptions.Append(layoutString);
dnnOptions.Append(":");
dnnOptions.Append(trainingStrategyString);
TString dnnMethodName = "TMVA_DNN_CPU";
// use GPU if available
#ifdef R__HAS_TMVAGPU
dnnOptions += ":Architecture=GPU";
dnnMethodName = "TMVA_DNN_GPU";
#elif defined(R__HAS_TMVACPU)
dnnOptions += ":Architecture=CPU";
#endif
factory.BookMethod(loader, TMVA::Types::kDL, dnnMethodName, dnnOptions);
}
/***
### Book Convolutional Neural Network in TMVA
For building a CNN one needs to define
- Input Layout : number of channels (in this case = 1) | image height | image width
- Batch Layout : batch size | number of channels | image size = (height*width)
Then one add Convolutional layers and MaxPool layers.
- For Convolutional layer the option string has to be:
- CONV | number of units | filter height | filter width | stride height | stride width | padding height | paddig
width | activation function
- note in this case we are using a filer 3x3 and padding=1 and stride=1 so we get the output dimension of the
conv layer equal to the input
- note we use after the first convolutional layer a batch normalization layer. This seems to help significatly the
convergence
- For the MaxPool layer:
- MAXPOOL | pool height | pool width | stride height | stride width
The RESHAPE layer is needed to flatten the output before the Dense layer
Note that to run the CNN is required to have CPU or GPU support
***/
if (useTMVACNN) {
TString inputLayoutString("InputLayout=1|16|16");
// Batch Layout
TString layoutString("Layout=CONV|10|3|3|1|1|1|1|RELU,BNORM,CONV|10|3|3|1|1|1|1|RELU,MAXPOOL|2|2|1|1,"
"RESHAPE|FLAT,DENSE|100|RELU,DENSE|1|LINEAR");
// Training strategies.
TString trainingString1("LearningRate=1e-3,Momentum=0.9,Repetitions=1,"
"ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,"
"MaxEpochs=20,WeightDecay=1e-4,Regularization=None,"
"Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0");
TString trainingStrategyString("TrainingStrategy=");
trainingStrategyString +=
trainingString1; // + "|" + trainingString2 + "|" + trainingString3; for concatenating more training strings
// Build full CNN Options.
TString cnnOptions("!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=None:"
"WeightInitialization=XAVIER");
cnnOptions.Append(":");
cnnOptions.Append(inputLayoutString);
cnnOptions.Append(":");
cnnOptions.Append(layoutString);
cnnOptions.Append(":");
cnnOptions.Append(trainingStrategyString);
//// New DL (CNN)
TString cnnMethodName = "TMVA_CNN_CPU";
// use GPU if available
#ifdef R__HAS_TMVAGPU
cnnOptions += ":Architecture=GPU";
cnnMethodName = "TMVA_CNN_GPU";
#else
cnnOptions += ":Architecture=CPU";
cnnMethodName = "TMVA_CNN_CPU";
#endif
factory.BookMethod(loader, TMVA::Types::kDL, cnnMethodName, cnnOptions);
}
/**
### Book Convolutional Neural Network in Keras using a generated model
**/
if (useKerasCNN) {
Info("TMVA_CNN_Classification", "Building convolutional keras model");
// create python script which can be executed
// crceate 2 conv2d layer + maxpool + dense
TMacro m;
m.AddLine("import tensorflow");
m.AddLine("from tensorflow.keras.models import Sequential");
m.AddLine("from tensorflow.keras.optimizers import Adam");
m.AddLine(
"from tensorflow.keras.layers import Input, Dense, Dropout, Flatten, Conv2D, MaxPooling2D, Reshape, BatchNormalization");
m.AddLine("");
m.AddLine("model = Sequential() ");
m.AddLine("model.add(Reshape((16, 16, 1), input_shape = (256, )))");
m.AddLine("model.add(Conv2D(10, kernel_size = (3, 3), kernel_initializer = 'glorot_normal',activation = "
"'relu', padding = 'same'))");
m.AddLine("model.add(BatchNormalization())");
m.AddLine("model.add(Conv2D(10, kernel_size = (3, 3), kernel_initializer = 'glorot_normal',activation = "
"'relu', padding = 'same'))");
// m.AddLine("model.add(BatchNormalization())");
m.AddLine("model.add(MaxPooling2D(pool_size = (2, 2), strides = (1,1))) ");
m.AddLine("model.add(Flatten())");
m.AddLine("model.add(Dense(256, activation = 'relu')) ");
m.AddLine("model.add(Dense(2, activation = 'sigmoid')) ");
m.AddLine("model.compile(loss = 'binary_crossentropy', optimizer = Adam(lr = 0.001), metrics = ['accuracy'])");
m.AddLine("model.save('model_cnn.h5')");
m.AddLine("model.summary()");
m.SaveSource("make_cnn_model.py");
// execute
gSystem->Exec("python make_cnn_model.py");
if (gSystem->AccessPathName("model_cnn.h5")) {
Warning("TMVA_CNN_Classification", "Error creating Keras model file - skip using Keras");
} else {
// book PyKeras method only if Keras model could be created
Info("TMVA_CNN_Classification", "Booking tf.Keras CNN model");
factory.BookMethod(
loader, TMVA::Types::kPyKeras, "PyKeras",
"H:!V:VarTransform=None:FilenameModel=model_cnn.h5:tf.keras:"
"FilenameTrainedModel=trained_model_cnn.h5:NumEpochs=20:BatchSize=100:"
"GpuOptions=allow_growth=True"); // needed for RTX NVidia card and to avoid TF allocates all GPU memory
}
}
if (usePyTorchCNN) {
Info("TMVA_CNN_Classification", "Using Convolutional PyTorch Model");
TString pyTorchFileName = gROOT->GetTutorialDir() + TString("/tmva/PyTorch_Generate_CNN_Model.py");
// check that pytorch can be imported and file defining the model and used later when booking the method is existing
if (gSystem->Exec("python -c 'import torch'") || gSystem->AccessPathName(pyTorchFileName) ) {
Warning("TMVA_CNN_Classification", "PyTorch is not installed or model building file is not existing - skip using PyTorch");
}
else {
// book PyTorch method only if PyTorch model could be created
Info("TMVA_CNN_Classification", "Booking PyTorch CNN model");
TString methodOpt = "H:!V:VarTransform=None:FilenameModel=PyTorchModelCNN.pt:"
"FilenameTrainedModel=PyTorchTrainedModelCNN.pt:NumEpochs=20:BatchSize=100";
methodOpt += TString(":UserCode=") + pyTorchFileName;
factory.BookMethod(loader, TMVA::Types::kPyTorch, "PyTorch", methodOpt);
}
}
//// ## Train Methods
factory.TrainAllMethods();
/// ## Test and Evaluate Methods
factory.TestAllMethods();
factory.EvaluateAllMethods();
/// ## Plot ROC Curve
auto c1 = factory.GetROCCurve(loader);
c1->Draw();
// close outputfile to save output file
outputFile->Close();
}
f
#define f(i)
Definition: RSha256.hxx:104
x2
static const double x2[5]
Definition: RooGaussKronrodIntegrator1D.cxx:364
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
Double_t
double Double_t
Definition: RtypesCore.h:59
Info
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
Definition: TError.cxx:220
Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
Warning
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition: TError.cxx:231
gROOT
#define gROOT
Definition: TROOT.h:406
gRandom
R__EXTERN TRandom * gRandom
Definition: TRandom.h:62
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
TCut
A specialized string object used for TTree selections.
Definition: TCut.h:25
TF1::SetParameters
virtual void SetParameters(const Double_t *params)
Definition: TF1.h:644
TF1::SetParameter
virtual void SetParameter(Int_t param, Double_t value)
Definition: TF1.h:634
TF2
A 2-Dim function with parameters.
Definition: TF2.h:29
TFile
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:54
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:3997
TFile::Close
void Close(Option_t *option="") override
Close a file.
Definition: TFile.cxx:879
TH1F::Reset
virtual void Reset(Option_t *option="")
Reset.
Definition: TH1.cxx:9947
TH1::FillRandom
virtual void FillRandom(const char *fname, Int_t ntimes=5000, TRandom *rng=nullptr)
Fill histogram following distribution in function fname.
Definition: TH1.cxx:3525
TH1::GetBinContent
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH1.cxx:4993
TH2D
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:292
TMVA::DataLoader::AddVariablesArray
void AddVariablesArray(const TString &expression, int size, char type='F', Double_t min=0, Double_t max=0)
user inserts discriminating array of variables in data set info in case input tree provides an array ...
Definition: DataLoader.cxx:503
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
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::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
TMVA::Factory
This is the main MVA steering class.
Definition: Factory.h:80
TMVA::PyMethodBase::PyInitialize
static void PyInitialize()
Initialize Python interpreter.
Definition: PyMethodBase.cxx:125
TMVA::Tools::Instance
static Tools & Instance()
Definition: Tools.cxx:75
TMVA::Types::kPyKeras
@ kPyKeras
Definition: Types.h:105
TMVA::Types::kBDT
@ kBDT
Definition: Types.h:88
TMVA::Types::kPyTorch
@ kPyTorch
Definition: Types.h:106
TMacro
Class supporting a collection of lines with C++ code.
Definition: TMacro.h:31
TRandom::Gaus
virtual Double_t Gaus(Double_t mean=0, Double_t sigma=1)
Samples a random number from the standard Normal (Gaussian) Distribution with the given mean and sigm...
Definition: TRandom.cxx:274
TRandom::SetSeed
virtual void SetSeed(ULong_t seed=0)
Set the random generator seed.
Definition: TRandom.cxx:608
TRandom::Uniform
virtual Double_t Uniform(Double_t x1=1)
Returns a uniform deviate on the interval (0, x1).
Definition: TRandom.cxx:672
TString
Basic string class.
Definition: TString.h:136
TString::Data
const char * Data() const
Definition: TString.h:369
TString::Format
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition: TString.cxx:2331
TSystem::Exec
virtual Int_t Exec(const char *shellcmd)
Execute a command.
Definition: TSystem.cxx:654
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
TSystem::Setenv
virtual void Setenv(const char *name, const char *value)
Set environment variable.
Definition: TSystem.cxx:1645
TTree
A TTree represents a columnar dataset.
Definition: TTree.h:79
TTree::GetEntries
virtual Long64_t GetEntries() const
Definition: TTree.h:459
c1
return c1
Definition: legend1.C:41
n
const Int_t n
Definition: legend1.C:16
h1
TH1F * h1
Definition: legend1.C:5
f1
TF1 * f1
Definition: legend1.C:11
ROOT::EnableImplicitMT
void EnableImplicitMT(UInt_t numthreads=0)
Enable ROOT's implicit multi-threading for all objects and methods that provide an internal paralleli...
Definition: TROOT.cxx:525
ROOT::GetThreadPoolSize
UInt_t GetThreadPoolSize()
Returns the size of ROOT's thread pool.
Definition: TROOT.cxx:563
m
auto * m
Definition: textangle.C:8
l
auto * l
Definition: textangle.C:4
Author
Lorenzo Moneta

Definition in file TMVA_CNN_Classification.C.