{
"cells": [
{
"cell_type": "markdown",
"id": "f42c6264",
"metadata": {},
"source": [
"# TMVA_CNN_Classification\n",
" TMVA Classification Example Using a Convolutional Neural Network\n",
"\n",
"This is an example of using a CNN in TMVA. We do classification using a toy image data set\n",
"that is generated when running the example macro\n",
"\n",
"\n",
"\n",
"\n",
"**Author:** Harshal Shende \n",
"This notebook tutorial was automatically generated with ROOTBOOK-izer from the macro found in the ROOT repository on Tuesday, May 19, 2026 at 08:22 PM."
]
},
{
"cell_type": "markdown",
"id": "d84710a2",
"metadata": {},
"source": [
"TMVA Classification Example Using a Convolutional Neural Network"
]
},
{
"cell_type": "markdown",
"id": "0a5b677e",
"metadata": {},
"source": [
" Helper function to create input images data\n",
" we create a signal and background 2D histograms from 2d gaussians\n",
" with a location (means in X and Y) different for each event\n",
" The difference between signal and background is in the gaussian width.\n",
" The width for the background gaussian is slightly larger than the signal width by few % values"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "eaedc0e3",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:47.838637Z",
"iopub.status.busy": "2026-05-19T20:22:47.838510Z",
"iopub.status.idle": "2026-05-19T20:22:48.835398Z",
"shell.execute_reply": "2026-05-19T20:22:48.834698Z"
}
},
"outputs": [],
"source": [
"import importlib.util\n",
"import os\n",
"\n",
"import ROOT\n",
"\n",
"opt = [1, 1, 1, 1, 1]\n",
"useTMVACNN = opt[0] if len(opt) > 0 else False\n",
"useKerasCNN = opt[1] if len(opt) > 1 else False\n",
"useTMVADNN = opt[2] if len(opt) > 2 else False\n",
"useTMVABDT = opt[3] if len(opt) > 3 else False\n",
"usePyTorchCNN = opt[4] if len(opt) > 4 else False\n",
"\n",
"TMVA = ROOT.TMVA\n",
"TFile = ROOT.TFile\n",
"\n",
"TMVA.Tools.Instance()\n",
"\n",
"def MakeImagesTree(n, nh, nw):\n",
" # image size (nh x nw)\n",
" ntot = nh * nw\n",
" fileOutName = \"images_data_16x16.root\"\n",
" nRndmEvts = 10000 # number of events we use to fill each image\n",
" delta_sigma = 0.1 # 5% difference in the sigma\n",
" pixelNoise = 5\n",
"\n",
" sX1 = 3\n",
" sY1 = 3\n",
" sX2 = sX1 + delta_sigma\n",
" sY2 = sY1 - delta_sigma\n",
" h1 = ROOT.TH2D(\"h1\", \"h1\", nh, 0, 10, nw, 0, 10)\n",
" h2 = ROOT.TH2D(\"h2\", \"h2\", nh, 0, 10, nw, 0, 10)\n",
" f1 = ROOT.TF2(\"f1\", \"xygaus\")\n",
" f2 = ROOT.TF2(\"f2\", \"xygaus\")\n",
" sgn = ROOT.TTree(\"sig_tree\", \"signal_tree\")\n",
" bkg = ROOT.TTree(\"bkg_tree\", \"background_tree\")\n",
"\n",
" f = TFile(fileOutName, \"RECREATE\")\n",
" x1 = ROOT.std.vector[\"float\"](ntot)\n",
" x2 = ROOT.std.vector[\"float\"](ntot)\n",
"\n",
" # create signal and background trees with a single branch\n",
" # an std::vector of size nh x nw containing the image data\n",
" bkg.Branch(\"vars\", \"std::vector\", x1)\n",
" sgn.Branch(\"vars\", \"std::vector\", x2)\n",
"\n",
" sgn.SetDirectory(f)\n",
" bkg.SetDirectory(f)\n",
"\n",
" f1.SetParameters(1, 5, sX1, 5, sY1)\n",
" f2.SetParameters(1, 5, sX2, 5, sY2)\n",
" ROOT.gRandom.SetSeed(0)\n",
" ROOT.Info(\"TMVA_CNN_Classification\", \"Filling ROOT tree \\n\")\n",
" for i in range(n):\n",
" if i % 1000 == 0:\n",
" print(\"Generating image event ...\", i)\n",
"\n",
" h1.Reset()\n",
" h2.Reset()\n",
" # generate random means in range [3,7] to be not too much on the border\n",
" f1.SetParameter(1, ROOT.gRandom.Uniform(3, 7))\n",
" f1.SetParameter(3, ROOT.gRandom.Uniform(3, 7))\n",
" f2.SetParameter(1, ROOT.gRandom.Uniform(3, 7))\n",
" f2.SetParameter(3, ROOT.gRandom.Uniform(3, 7))\n",
"\n",
" h1.FillRandom(f1, nRndmEvts)\n",
" h2.FillRandom(f2, nRndmEvts)\n",
"\n",
" for k in range(nh):\n",
" for l in range(nw):\n",
" m = k * nw + l\n",
" # add some noise in each bin\n",
" x1[m] = h1.GetBinContent(k + 1, l + 1) + ROOT.gRandom.Gaus(0, pixelNoise)\n",
" x2[m] = h2.GetBinContent(k + 1, l + 1) + ROOT.gRandom.Gaus(0, pixelNoise)\n",
"\n",
" sgn.Fill()\n",
" bkg.Fill()\n",
"\n",
" sgn.Write()\n",
" bkg.Write()\n",
"\n",
" print(\"Signal and background tree with images data written to the file %s\", f.GetName())\n",
" sgn.Print()\n",
" bkg.Print()\n",
" f.Close()\n",
"\n",
"hasGPU = \"tmva-gpu\" in ROOT.gROOT.GetConfigFeatures()\n",
"hasCPU = \"tmva-cpu\" in ROOT.gROOT.GetConfigFeatures()\n",
"\n",
"nevt = 1000 # use a larger value to get better results\n",
"\n",
"if (not hasCPU and not hasGPU) :\n",
" ROOT.Warning(\"TMVA_CNN_Classificaton\",\"ROOT is not supporting tmva-cpu and tmva-gpu skip using TMVA-DNN and TMVA-CNN\")\n",
" useTMVACNN = False\n",
" useTMVADNN = False\n",
"\n",
"if \"tmva-pymva\" not in ROOT.gROOT.GetConfigFeatures():\n",
" useKerasCNN = False\n",
" usePyTorchCNN = False\n",
"else:\n",
" TMVA.PyMethodBase.PyInitialize()\n",
"\n",
"if not useTMVACNN:\n",
" ROOT.Warning(\n",
" \"TMVA_CNN_Classificaton\",\n",
" \"TMVA is not build with GPU or CPU multi-thread support. Cannot use TMVA Deep Learning for CNN\",\n",
" )\n",
"\n",
"writeOutputFile = True\n",
"\n",
"num_threads = 4 # use max 4 threads\n",
"max_epochs = 10 # maximum number of epochs used for training"
]
},
{
"cell_type": "markdown",
"id": "e6f9ad83",
"metadata": {},
"source": [
"do enable MT running"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "46e27e53",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:48.848418Z",
"iopub.status.busy": "2026-05-19T20:22:48.848277Z",
"iopub.status.idle": "2026-05-19T20:22:48.999406Z",
"shell.execute_reply": "2026-05-19T20:22:48.998740Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Running with nthreads = 4\n"
]
}
],
"source": [
"if \"imt\" in ROOT.gROOT.GetConfigFeatures():\n",
" ROOT.EnableImplicitMT(num_threads)\n",
" ROOT.gSystem.Setenv(\"OMP_NUM_THREADS\", \"1\") # switch OFF MT in OpenBLAS\n",
" print(\"Running with nthreads = {}\".format(ROOT.GetThreadPoolSize()))\n",
"else:\n",
" print(\"Running in serial mode since ROOT does not support MT\")\n",
"\n",
"\n",
"\n",
"\n",
"outputFile = None\n",
"if writeOutputFile:\n",
" outputFile = TFile.Open(\"TMVA_CNN_ClassificationOutput.root\", \"RECREATE\")"
]
},
{
"cell_type": "markdown",
"id": "a82699f4",
"metadata": {},
"source": [
" Create TMVA Factory"
]
},
{
"cell_type": "markdown",
"id": "a8006760",
"metadata": {},
"source": [
"Create the Factory class. Later you can choose the methods\n",
"whose performance you'd like to investigate."
]
},
{
"cell_type": "markdown",
"id": "264367c3",
"metadata": {},
"source": [
"The factory is the major TMVA object you have to interact with. Here is the list of parameters you need to pass"
]
},
{
"cell_type": "markdown",
"id": "c8489b63",
"metadata": {},
"source": [
"- The first argument is the base of the name of all the output\n",
" weight files in the directory weight/ that will be created with the\n",
" method parameters"
]
},
{
"cell_type": "markdown",
"id": "3dd4efb9",
"metadata": {},
"source": [
"- The second argument is the output file for the training results"
]
},
{
"cell_type": "markdown",
"id": "2aba3cbb",
"metadata": {},
"source": [
"- The third argument is a string option defining some general configuration for the TMVA session.\n",
"For example all TMVA output can be suppressed by removing the \"!\" (not) in front of the \"Silent\" argument in the\n",
"option string"
]
},
{
"cell_type": "markdown",
"id": "94152466",
"metadata": {},
"source": [
"- note that we disable any pre-transformation of the input variables and we avoid computing correlations between\n",
"input variables"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "6af7ffe1",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:49.001275Z",
"iopub.status.busy": "2026-05-19T20:22:49.001151Z",
"iopub.status.idle": "2026-05-19T20:22:49.124397Z",
"shell.execute_reply": "2026-05-19T20:22:49.123740Z"
}
},
"outputs": [],
"source": [
"factory = TMVA.Factory(\n",
" \"TMVA_CNN_Classification\",\n",
" outputFile,\n",
" V=False,\n",
" ROC=True,\n",
" Silent=False,\n",
" Color=True,\n",
" AnalysisType=\"Classification\",\n",
" Transformations=None,\n",
" Correlations=False,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "6f8a2673",
"metadata": {},
"source": [
" Declare DataLoader(s)"
]
},
{
"cell_type": "markdown",
"id": "a82af68b",
"metadata": {},
"source": [
"The next step is to declare the DataLoader class that deals with input variables"
]
},
{
"cell_type": "markdown",
"id": "d2ee9f7c",
"metadata": {},
"source": [
"Define the input variables that shall be used for the MVA training\n",
"note that you may also use variable expressions, which can be parsed by TTree::Draw( \"expression\" )]"
]
},
{
"cell_type": "markdown",
"id": "ce25c0a6",
"metadata": {},
"source": [
"In this case the input data consists of an image of 16x16 pixels. Each single pixel is a branch in a ROOT TTree"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "d6f9600c",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:49.126508Z",
"iopub.status.busy": "2026-05-19T20:22:49.126383Z",
"iopub.status.idle": "2026-05-19T20:22:49.238750Z",
"shell.execute_reply": "2026-05-19T20:22:49.237963Z"
}
},
"outputs": [],
"source": [
"loader = TMVA.DataLoader(\"dataset\")"
]
},
{
"cell_type": "markdown",
"id": "5ec6c7e6",
"metadata": {},
"source": [
" Setup Dataset(s)"
]
},
{
"cell_type": "markdown",
"id": "cb2caa42",
"metadata": {},
"source": [
"Define input data file and signal and background trees"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "07e07f50",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:49.240710Z",
"iopub.status.busy": "2026-05-19T20:22:49.240565Z",
"iopub.status.idle": "2026-05-19T20:22:49.344092Z",
"shell.execute_reply": "2026-05-19T20:22:49.343315Z"
}
},
"outputs": [],
"source": [
"imgSize = 16 * 16\n",
"inputFileName = \"images_data_16x16.root\""
]
},
{
"cell_type": "markdown",
"id": "f6a842e7",
"metadata": {},
"source": [
"if the input file does not exist create it"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "89b18401",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:49.353515Z",
"iopub.status.busy": "2026-05-19T20:22:49.353371Z",
"iopub.status.idle": "2026-05-19T20:22:52.024195Z",
"shell.execute_reply": "2026-05-19T20:22:52.023447Z"
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Info in : Filling ROOT tree \n",
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Generating image event ... 0\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Signal and background tree with images data written to the file %s images_data_16x16.root\n",
"******************************************************************************\n",
"*Tree :sig_tree : signal_tree *\n",
"*Entries : 1000 : Total = 1042365 bytes File Size = 927546 *\n",
"* : : Tree compression factor = 1.12 *\n",
"******************************************************************************\n",
"*Br 0 :vars : vector *\n",
"*Entries : 1000 : Total Size= 1041947 bytes File Size = 926844 *\n",
"*Baskets : 34 : Basket Size= 32000 bytes Compression= 1.12 *\n",
"*............................................................................*\n",
"******************************************************************************\n",
"*Tree :bkg_tree : background_tree *\n",
"*Entries : 1000 : Total = 1042373 bytes File Size = 927294 *\n",
"* : : Tree compression factor = 1.12 *\n",
"******************************************************************************\n",
"*Br 0 :vars : vector *\n",
"*Entries : 1000 : Total Size= 1041947 bytes File Size = 926582 *\n",
"*Baskets : 34 : Basket Size= 32000 bytes Compression= 1.12 *\n",
"*............................................................................*\n"
]
}
],
"source": [
"if ROOT.gSystem.AccessPathName(inputFileName):\n",
" MakeImagesTree(nevt, 16, 16)\n",
"\n",
"inputFile = TFile.Open(inputFileName)\n",
"if inputFile is None:\n",
" ROOT.Warning(\"TMVA_CNN_Classification\", \"Error opening input file %s - exit\", inputFileName.Data())"
]
},
{
"cell_type": "markdown",
"id": "e39bd423",
"metadata": {},
"source": [
"inputFileName = \"tmva_class_example.root\""
]
},
{
"cell_type": "markdown",
"id": "38d0e9e3",
"metadata": {},
"source": [
"--- Register the training and test trees"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "39d92e4d",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.025781Z",
"iopub.status.busy": "2026-05-19T20:22:52.025651Z",
"iopub.status.idle": "2026-05-19T20:22:52.141098Z",
"shell.execute_reply": "2026-05-19T20:22:52.140620Z"
}
},
"outputs": [],
"source": [
"signalTree = inputFile.Get(\"sig_tree\")\n",
"backgroundTree = inputFile.Get(\"bkg_tree\")\n",
"\n",
"nEventsSig = signalTree.GetEntries()\n",
"nEventsBkg = backgroundTree.GetEntries()"
]
},
{
"cell_type": "markdown",
"id": "b87e7d58",
"metadata": {},
"source": [
"global event weights per tree (see below for setting event-wise weights)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "42caec7f",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.157413Z",
"iopub.status.busy": "2026-05-19T20:22:52.157269Z",
"iopub.status.idle": "2026-05-19T20:22:52.260523Z",
"shell.execute_reply": "2026-05-19T20:22:52.260079Z"
}
},
"outputs": [],
"source": [
"signalWeight = 1.0\n",
"backgroundWeight = 1.0"
]
},
{
"cell_type": "markdown",
"id": "7371640c",
"metadata": {},
"source": [
"You can add an arbitrary number of signal or background trees"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "4c2838fd",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.262939Z",
"iopub.status.busy": "2026-05-19T20:22:52.262818Z",
"iopub.status.idle": "2026-05-19T20:22:52.377144Z",
"shell.execute_reply": "2026-05-19T20:22:52.376505Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"DataSetInfo : [dataset] : Added class \"Signal\"\n",
" : Add Tree sig_tree of type Signal with 1000 events\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"DataSetInfo : [dataset] : Added class \"Background\"\n",
" : Add Tree bkg_tree of type Background with 1000 events\n"
]
}
],
"source": [
"loader.AddSignalTree(signalTree, signalWeight)\n",
"loader.AddBackgroundTree(backgroundTree, backgroundWeight)"
]
},
{
"cell_type": "markdown",
"id": "78ff55c9",
"metadata": {},
"source": [
" add event variables (image)\n",
" use new method (from ROOT 6.20 to add a variable array for all image data)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "4d0ab98c",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.378541Z",
"iopub.status.busy": "2026-05-19T20:22:52.378420Z",
"iopub.status.idle": "2026-05-19T20:22:52.487240Z",
"shell.execute_reply": "2026-05-19T20:22:52.486643Z"
}
},
"outputs": [],
"source": [
"loader.AddVariablesArray(\"vars\", imgSize)"
]
},
{
"cell_type": "markdown",
"id": "28b0d557",
"metadata": {},
"source": [
"Set individual event weights (the variables must exist in the original TTree)\n",
" for signal : factory->SetSignalWeightExpression (\"weight1*weight2\");\n",
" for background: factory->SetBackgroundWeightExpression(\"weight1*weight2\");\n",
"loader->SetBackgroundWeightExpression( \"weight\" );"
]
},
{
"cell_type": "markdown",
"id": "ade73f13",
"metadata": {},
"source": [
"Apply additional cuts on the signal and background samples (can be different)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "e1edb3da",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.489086Z",
"iopub.status.busy": "2026-05-19T20:22:52.488965Z",
"iopub.status.idle": "2026-05-19T20:22:52.592368Z",
"shell.execute_reply": "2026-05-19T20:22:52.591726Z"
}
},
"outputs": [],
"source": [
"mycuts = \"\" # for example: TCut mycuts = \"abs(var1)<0.5 && abs(var2-0.5)<1\";\n",
"mycutb = \"\" # for example: TCut mycutb = \"abs(var1)<0.5\";"
]
},
{
"cell_type": "markdown",
"id": "d5b6e390",
"metadata": {},
"source": [
"Tell the factory how to use the training and testing events\n",
"If no numbers of events are given, half of the events in the tree are used\n",
"for training, and the other half for testing:\n",
" loader.PrepareTrainingAndTestTree( mycut, \"SplitMode=random:!V\" );\n",
"It is possible also to specify the number of training and testing events,\n",
"note we disable the computation of the correlation matrix of the input variables"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "1875b420",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.601355Z",
"iopub.status.busy": "2026-05-19T20:22:52.601230Z",
"iopub.status.idle": "2026-05-19T20:22:52.704585Z",
"shell.execute_reply": "2026-05-19T20:22:52.703972Z"
}
},
"outputs": [],
"source": [
"nTrainSig = 0.8 * nEventsSig\n",
"nTrainBkg = 0.8 * nEventsBkg"
]
},
{
"cell_type": "markdown",
"id": "5fb2775f",
"metadata": {},
"source": [
"build the string options for DataLoader::PrepareTrainingAndTestTree"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "363beff7",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.706370Z",
"iopub.status.busy": "2026-05-19T20:22:52.706251Z",
"iopub.status.idle": "2026-05-19T20:22:52.818258Z",
"shell.execute_reply": "2026-05-19T20:22:52.817648Z"
}
},
"outputs": [],
"source": [
"loader.PrepareTrainingAndTestTree(\n",
" mycuts,\n",
" mycutb,\n",
" nTrain_Signal=nTrainSig,\n",
" nTrain_Background=nTrainBkg,\n",
" SplitMode=\"Random\",\n",
" SplitSeed=100,\n",
" NormMode=\"NumEvents\",\n",
" V=False,\n",
" CalcCorrelations=False,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "1ea5fbd5",
"metadata": {},
"source": [
"DataSetInfo : [dataset] : Added class \"Signal\"\n",
" : Add Tree sig_tree of type Signal with 10000 events\n",
" DataSetInfo : [dataset] : Added class \"Background\"\n",
" : Add Tree bkg_tree of type Background with 10000 events"
]
},
{
"cell_type": "markdown",
"id": "76e6f9dc",
"metadata": {},
"source": [
"signalTree.Print();"
]
},
{
"cell_type": "markdown",
"id": "4656228d",
"metadata": {},
"source": [
"Booking Methods"
]
},
{
"cell_type": "markdown",
"id": "fa61888d",
"metadata": {},
"source": [
"Here we book the TMVA methods. We book a Boosted Decision Tree method (BDT)"
]
},
{
"cell_type": "markdown",
"id": "ea75a7d4",
"metadata": {},
"source": [
"Boosted Decision Trees"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "8e3bb3d2",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:52.820028Z",
"iopub.status.busy": "2026-05-19T20:22:52.819910Z",
"iopub.status.idle": "2026-05-19T20:22:53.008285Z",
"shell.execute_reply": "2026-05-19T20:22:53.007699Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Factory : Booking method: \u001b[1mBDT\u001b[0m\n",
" : \n",
" : Rebuilding Dataset dataset\n",
" : Building event vectors for type 2 Signal\n",
" : Dataset[dataset] : create input formulas for tree sig_tree\n",
" : Using variable vars[0] from array expression vars of size 256\n",
" : Building event vectors for type 2 Background\n",
" : Dataset[dataset] : create input formulas for tree bkg_tree\n",
" : Using variable vars[0] from array expression vars of size 256\n",
"DataSetFactory : [dataset] : Number of events in input trees\n",
" : \n",
" : \n",
" : Number of training and testing events\n",
" : ---------------------------------------------------------------------------\n",
" : Signal -- training events : 800\n",
" : Signal -- testing events : 200\n",
" : Signal -- training and testing events: 1000\n",
" : Background -- training events : 800\n",
" : Background -- testing events : 200\n",
" : Background -- training and testing events: 1000\n",
" : \n"
]
}
],
"source": [
"if useTMVABDT:\n",
" factory.BookMethod(\n",
" loader,\n",
" TMVA.Types.kBDT,\n",
" \"BDT\",\n",
" V=False,\n",
" NTrees=400,\n",
" MinNodeSize=\"2.5%\",\n",
" MaxDepth=2,\n",
" BoostType=\"AdaBoost\",\n",
" AdaBoostBeta=0.5,\n",
" UseBaggedBoost=True,\n",
" BaggedSampleFraction=0.5,\n",
" SeparationType=\"GiniIndex\",\n",
" nCuts=20,\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "258e65e1",
"metadata": {},
"source": [
"## Booking Deep Neural Network"
]
},
{
"cell_type": "markdown",
"id": "1d4b920c",
"metadata": {},
"source": [
"Here we book the DNN of TMVA. See the example TMVA_Higgs_Classification.C for a detailed description of the\n",
"options"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "69d5e7c5",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:53.009975Z",
"iopub.status.busy": "2026-05-19T20:22:53.009852Z",
"iopub.status.idle": "2026-05-19T20:22:53.133497Z",
"shell.execute_reply": "2026-05-19T20:22:53.132889Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Factory : Booking method: \u001b[1mTMVA_DNN_CPU\u001b[0m\n",
" : \n",
" : Parsing option string: \n",
" : ... \"!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,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.,MaxEpochs=10:Architecture=CPU\"\n",
" : The following options are set:\n",
" : - By User:\n",
" : \n",
" : - Default:\n",
" : Boost_num: \"0\" [Number of times the classifier will be boosted]\n",
" : Parsing option string: \n",
" : ... \"!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,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.,MaxEpochs=10:Architecture=CPU\"\n",
" : The following options are set:\n",
" : - By User:\n",
" : V: \"True\" [Verbose output (short form of \"VerbosityLevel\" below - overrides the latter one)]\n",
" : 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)\"]\n",
" : H: \"False\" [Print method-specific help message]\n",
" : Layout: \"DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,DENSE|1|LINEAR\" [Layout of the network.]\n",
" : ErrorStrategy: \"CROSSENTROPY\" [Loss function: Mean squared error (regression) or cross entropy (binary classification).]\n",
" : WeightInitialization: \"XAVIER\" [Weight initialization strategy]\n",
" : Architecture: \"CPU\" [Which architecture to perform the training on.]\n",
" : TrainingStrategy: \"LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.,MaxEpochs=10\" [Defines the training strategies.]\n",
" : - Default:\n",
" : VerbosityLevel: \"Default\" [Verbosity level]\n",
" : CreateMVAPdfs: \"False\" [Create PDFs for classifier outputs (signal and background)]\n",
" : IgnoreNegWeightsInTraining: \"False\" [Events with negative weights are ignored in the training (but are included for testing and performance evaluation)]\n",
" : InputLayout: \"0|0|0\" [The Layout of the input]\n",
" : BatchLayout: \"0|0|0\" [The Layout of the batch]\n",
" : RandomSeed: \"0\" [Random seed used for weight initialization and batch shuffling]\n",
" : 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%)]\n",
" : Will now use the CPU architecture with BLAS and IMT support !\n"
]
}
],
"source": [
"if useTMVADNN:\n",
" layoutString = ROOT.TString(\n",
" \"DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,BNORM,DENSE|100|RELU,DENSE|1|LINEAR\"\n",
" )\n",
"\n",
" # Training strategies\n",
" # one can catenate several training strings with different parameters (e.g. learning rates or regularizations\n",
" # parameters) The training string must be concatenated with the `|` delimiter\n",
" trainingString1 = ROOT.TString(\n",
" \"LearningRate=1e-3,Momentum=0.9,Repetitions=1,\"\n",
" \"ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,\"\n",
" \"WeightDecay=1e-4,Regularization=None,\"\n",
" \"Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.\"\n",
" ) # + \"|\" + trainingString2 + ...\n",
" trainingString1 += \",MaxEpochs=\" + str(max_epochs)\n",
"\n",
" # Build now the full DNN Option string\n",
" dnnMethodName = \"TMVA_DNN_CPU\"\n",
"\n",
" # use GPU if available\n",
" dnnOptions = \"CPU\"\n",
" if hasGPU :\n",
" dnnOptions = \"GPU\"\n",
" dnnMethodName = \"TMVA_DNN_GPU\"\n",
"\n",
" factory.BookMethod(\n",
" loader,\n",
" TMVA.Types.kDL,\n",
" dnnMethodName,\n",
" H=False,\n",
" V=True,\n",
" ErrorStrategy=\"CROSSENTROPY\",\n",
" VarTransform=None,\n",
" WeightInitialization=\"XAVIER\",\n",
" Layout=layoutString,\n",
" TrainingStrategy=trainingString1,\n",
" Architecture=dnnOptions\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "b1bd4457",
"metadata": {},
"source": [
"# Book Convolutional Neural Network in TMVA"
]
},
{
"cell_type": "markdown",
"id": "41c44add",
"metadata": {},
"source": [
"For building a CNN one needs to define"
]
},
{
"cell_type": "markdown",
"id": "d1d76f5f",
"metadata": {},
"source": [
"- Input Layout : number of channels (in this case = 1) | image height | image width\n",
"- Batch Layout : batch size | number of channels | image size = (height*width)"
]
},
{
"cell_type": "markdown",
"id": "58f238f9",
"metadata": {},
"source": [
"Then one add Convolutional layers and MaxPool layers."
]
},
{
"cell_type": "markdown",
"id": "8009691d",
"metadata": {},
"source": [
"- For Convolutional layer the option string has to be:\n",
"- CONV | number of units | filter height | filter width | stride height | stride width | padding height | paddig\n",
"width | activation function"
]
},
{
"cell_type": "markdown",
"id": "758c68a8",
"metadata": {},
"source": [
"- note in this case we are using a filer 3x3 and padding=1 and stride=1 so we get the output dimension of the\n",
"conv layer equal to the input"
]
},
{
"cell_type": "markdown",
"id": "793250ee",
"metadata": {},
"source": [
"- note we use after the first convolutional layer a batch normalization layer. This seems to help significantly the\n",
"convergence"
]
},
{
"cell_type": "markdown",
"id": "309405ad",
"metadata": {},
"source": [
"- For the MaxPool layer:\n",
"- MAXPOOL | pool height | pool width | stride height | stride width"
]
},
{
"cell_type": "markdown",
"id": "f2800e70",
"metadata": {},
"source": [
"The RESHAPE layer is needed to flatten the output before the Dense layer"
]
},
{
"cell_type": "markdown",
"id": "bf1bbe6a",
"metadata": {},
"source": [
"Note that to run the CNN is required to have CPU or GPU support"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "f3bfb6d1",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:53.135438Z",
"iopub.status.busy": "2026-05-19T20:22:53.135314Z",
"iopub.status.idle": "2026-05-19T20:22:53.242802Z",
"shell.execute_reply": "2026-05-19T20:22:53.242142Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Factory : Booking method: \u001b[1mTMVA_CNN_CPU\u001b[0m\n",
" : \n",
" : Parsing option string: \n",
" : ... \"!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,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0,MaxEpochs=10:Architecture=CPU\"\n",
" : The following options are set:\n",
" : - By User:\n",
" : \n",
" : - Default:\n",
" : Boost_num: \"0\" [Number of times the classifier will be boosted]\n",
" : Parsing option string: \n",
" : ... \"!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,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0,MaxEpochs=10:Architecture=CPU\"\n",
" : The following options are set:\n",
" : - By User:\n",
" : V: \"True\" [Verbose output (short form of \"VerbosityLevel\" below - overrides the latter one)]\n",
" : 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)\"]\n",
" : H: \"False\" [Print method-specific help message]\n",
" : InputLayout: \"1|16|16\" [The Layout of the input]\n",
" : 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.]\n",
" : ErrorStrategy: \"CROSSENTROPY\" [Loss function: Mean squared error (regression) or cross entropy (binary classification).]\n",
" : WeightInitialization: \"XAVIER\" [Weight initialization strategy]\n",
" : Architecture: \"CPU\" [Which architecture to perform the training on.]\n",
" : TrainingStrategy: \"LearningRate=1e-3,Momentum=0.9,Repetitions=1,ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,WeightDecay=1e-4,Regularization=None,Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0,MaxEpochs=10\" [Defines the training strategies.]\n",
" : - Default:\n",
" : VerbosityLevel: \"Default\" [Verbosity level]\n",
" : CreateMVAPdfs: \"False\" [Create PDFs for classifier outputs (signal and background)]\n",
" : IgnoreNegWeightsInTraining: \"False\" [Events with negative weights are ignored in the training (but are included for testing and performance evaluation)]\n",
" : BatchLayout: \"0|0|0\" [The Layout of the batch]\n",
" : RandomSeed: \"0\" [Random seed used for weight initialization and batch shuffling]\n",
" : 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%)]\n",
" : Will now use the CPU architecture with BLAS and IMT support !\n"
]
}
],
"source": [
"if useTMVACNN:\n",
" # Training strategies.\n",
" trainingString1 = ROOT.TString(\n",
" \"LearningRate=1e-3,Momentum=0.9,Repetitions=1,\"\n",
" \"ConvergenceSteps=5,BatchSize=100,TestRepetitions=1,\"\n",
" \"WeightDecay=1e-4,Regularization=None,\"\n",
" \"Optimizer=ADAM,DropConfig=0.0+0.0+0.0+0.0\"\n",
" )\n",
" trainingString1 += \",MaxEpochs=\" + str(max_epochs)\n",
"\n",
" ## New DL (CNN)\n",
" cnnMethodName = \"TMVA_CNN_CPU\"\n",
" cnnOptions = \"CPU\"\n",
" # use GPU if available\n",
" if hasGPU:\n",
" cnnOptions = \"GPU\"\n",
" cnnMethodName = \"TMVA_CNN_GPU\"\n",
"\n",
" factory.BookMethod(\n",
" loader,\n",
" TMVA.Types.kDL,\n",
" cnnMethodName,\n",
" H=False,\n",
" V=True,\n",
" ErrorStrategy=\"CROSSENTROPY\",\n",
" VarTransform=None,\n",
" WeightInitialization=\"XAVIER\",\n",
" InputLayout=\"1|16|16\",\n",
" 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\",\n",
" TrainingStrategy=trainingString1,\n",
" Architecture=cnnOptions,\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "d858bb71",
"metadata": {},
"source": [
"# Book Convolutional Neural Network in Keras using a generated model"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "6679e775",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:53.244243Z",
"iopub.status.busy": "2026-05-19T20:22:53.244118Z",
"iopub.status.idle": "2026-05-19T20:22:53.350306Z",
"shell.execute_reply": "2026-05-19T20:22:53.349704Z"
}
},
"outputs": [],
"source": [
"if usePyTorchCNN:\n",
" ROOT.Info(\"TMVA_CNN_Classification\", \"Using Convolutional PyTorch Model\")\n",
" pyTorchFileName = str(ROOT.gROOT.GetTutorialDir())\n",
" pyTorchFileName += \"/machine_learning/PyTorch_Generate_CNN_Model.py\"\n",
" # check that pytorch can be imported and file defining the model exists\n",
" torch_spec = importlib.util.find_spec(\"torch\")\n",
" if torch_spec is not None and os.path.exists(pyTorchFileName):\n",
" #cmd = str(ROOT.TMVA.Python_Executable()) + \" \" + pyTorchFileName\n",
" #os.system(cmd)\n",
" #import PyTorch_Generate_CNN_Model\n",
" ROOT.Info(\"TMVA_CNN_Classification\", \"Booking PyTorch CNN model\")\n",
" factory.BookMethod(\n",
" loader,\n",
" TMVA.Types.kPyTorch,\n",
" \"PyTorch\",\n",
" H=True,\n",
" V=False,\n",
" VarTransform=None,\n",
" FilenameModel=\"PyTorchModelCNN.pt\",\n",
" FilenameTrainedModel=\"PyTorchTrainedModelCNN.pt\",\n",
" NumEpochs=max_epochs,\n",
" BatchSize=100,\n",
" UserCode=str(pyTorchFileName)\n",
" )\n",
" else:\n",
" ROOT.Warning(\n",
" \"TMVA_CNN_Classification\",\n",
" \"PyTorch is not installed or model building file is not existing - skip using PyTorch\",\n",
" )\n",
"\n",
"if useKerasCNN:\n",
" ROOT.Info(\"TMVA_CNN_Classification\", \"Building convolutional keras model\")\n",
" # create python script which can be executed\n",
" # create 2 conv2d layer + maxpool + dense\n",
" # from keras.initializers import TruncatedNormal\n",
" # from keras import initializations\n",
" from tensorflow.keras.layers import Conv2D, Dense, Flatten, MaxPooling2D, Reshape\n",
" from tensorflow.keras.models import Sequential\n",
" from tensorflow.keras.optimizers import Adam\n",
"\n",
" # from keras.callbacks import ReduceLROnPlateau\n",
" model = Sequential()\n",
" model.add(Reshape((16, 16, 1), input_shape=(256,)))\n",
" model.add(Conv2D(10, kernel_size=(3, 3), kernel_initializer=\"TruncatedNormal\", activation=\"relu\", padding=\"same\"))\n",
" model.add(Conv2D(10, kernel_size=(3, 3), kernel_initializer=\"TruncatedNormal\", activation=\"relu\", padding=\"same\"))\n",
" # stride for maxpool is equal to pool size\n",
" model.add(MaxPooling2D(pool_size=(2, 2)))\n",
" model.add(Flatten())\n",
" model.add(Dense(64, activation=\"tanh\"))\n",
" # model.add(Dropout(0.2))\n",
" model.add(Dense(2, activation=\"sigmoid\"))\n",
" model.compile(loss=\"binary_crossentropy\", optimizer=Adam(learning_rate=0.001), weighted_metrics=[\"accuracy\"])\n",
" model.save(\"model_cnn.keras\")\n",
" model.summary()\n",
"\n",
" if not os.path.exists(\"model_cnn.keras\"):\n",
" raise FileNotFoundError(\"Error creating Keras model file - skip using Keras\")\n",
" else:\n",
" # book PyKeras method only if Keras model could be created\n",
" ROOT.Info(\"TMVA_CNN_Classification\", \"Booking convolutional keras model\")\n",
" factory.BookMethod(\n",
" loader,\n",
" TMVA.Types.kPyKeras,\n",
" \"PyKeras\",\n",
" H=True,\n",
" V=False,\n",
" VarTransform=None,\n",
" FilenameModel=\"model_cnn.keras\",\n",
" FilenameTrainedModel=\"trained_model_cnn.keras\",\n",
" NumEpochs=max_epochs,\n",
" BatchSize=100,\n",
" GpuOptions=\"allow_growth=True\",\n",
" ) # needed for RTX NVidia card and to avoid TF allocates all GPU memory"
]
},
{
"cell_type": "markdown",
"id": "b16c522f",
"metadata": {},
"source": [
" Train Methods"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "831400c8",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:22:53.351946Z",
"iopub.status.busy": "2026-05-19T20:22:53.351828Z",
"iopub.status.idle": "2026-05-19T20:23:03.698945Z",
"shell.execute_reply": "2026-05-19T20:23:03.698315Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Factory : \u001b[1mTrain all methods\u001b[0m\n",
"Factory : Train method: BDT for Classification\n",
" : \n",
"BDT : #events: (reweighted) sig: 800 bkg: 800\n",
" : #events: (unweighted) sig: 800 bkg: 800\n",
" : Training 400 Decision Trees ... patience please\n",
" : Elapsed time for training with 1600 events: 1.33 sec \n",
"BDT : [dataset] : Evaluation of BDT on training sample (1600 events)\n",
"BDT : [dataset] : Evaluation of BDT on training sample (1600 events)\n",
" : Elapsed time for evaluation of 1600 events: 0.0144 sec \n",
" : Elapsed time for evaluation of 1600 events: 0.0145 sec \n",
" : Creating xml weight file: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_BDT.weights.xml\u001b[0m\n",
" : Creating standalone class: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_BDT.class.C\u001b[0m\n",
" : TMVA_CNN_ClassificationOutput.root:/dataset/Method_BDT/BDT\n",
"Factory : Training finished\n",
" : \n",
"Factory : Train method: TMVA_DNN_CPU for Classification\n",
" : \n",
" : Start of deep neural network training on CPU using MT, nthreads = 4\n",
" : \n",
" : ***** Deep Learning Network *****\n",
"DEEP NEURAL NETWORK: Depth = 8 Input = ( 1, 1, 256 ) Batch size = 100 Loss function = C\n",
"\tLayer 0\t DENSE Layer: \t ( Input = 256 , Width = 100 ) \tOutput = ( 1 , 100 , 100 ) \t Activation Function = Relu\n",
"\tLayer 1\t BATCH NORM Layer: \t Input/Output = ( 100 , 100 , 1 ) \t Norm dim = 100\t axis = -1\n",
"\n",
"\tLayer 2\t DENSE Layer: \t ( Input = 100 , Width = 100 ) \tOutput = ( 1 , 100 , 100 ) \t Activation Function = Relu\n",
"\tLayer 3\t BATCH NORM Layer: \t Input/Output = ( 100 , 100 , 1 ) \t Norm dim = 100\t axis = -1\n",
"\n",
"\tLayer 4\t DENSE Layer: \t ( Input = 100 , Width = 100 ) \tOutput = ( 1 , 100 , 100 ) \t Activation Function = Relu\n",
"\tLayer 5\t BATCH NORM Layer: \t Input/Output = ( 100 , 100 , 1 ) \t Norm dim = 100\t axis = -1\n",
"\n",
"\tLayer 6\t DENSE Layer: \t ( Input = 100 , Width = 100 ) \tOutput = ( 1 , 100 , 100 ) \t Activation Function = Relu\n",
"\tLayer 7\t DENSE Layer: \t ( Input = 100 , Width = 1 ) \tOutput = ( 1 , 100 , 1 ) \t Activation Function = Identity\n",
" : Using 1280 events for training and 320 for testing\n",
" : Compute initial loss on the validation data \n",
" : Training phase 1 of 1: Optimizer ADAM (beta1=0.9,beta2=0.999,eps=1e-07) Learning rate = 0.001 regularization 0 minimum error = 55.3663\n",
" : --------------------------------------------------------------\n",
" : Epoch | Train Err. Val. Err. t(s)/epoch t(s)/Loss nEvents/s Conv. Steps\n",
" : --------------------------------------------------------------\n",
" : Start epoch iteration ...\n",
" : 1 Minimum Test error found - save the configuration \n",
" : 1 | 0.982467 1.03173 0.0824915 0.00622221 15733.7 0\n",
" : 2 Minimum Test error found - save the configuration \n",
" : 2 | 0.686428 0.840733 0.0820542 0.0059937 15776.9 0\n",
" : 3 | 0.592942 0.876818 0.0847861 0.00613546 15257.3 1\n",
" : 4 Minimum Test error found - save the configuration \n",
" : 4 | 0.509037 0.737107 0.0841998 0.00605847 15356.8 0\n",
" : 5 Minimum Test error found - save the configuration \n",
" : 5 | 0.428789 0.67943 0.0827547 0.00612587 15659.9 0\n",
" : 6 Minimum Test error found - save the configuration \n",
" : 6 | 0.374478 0.675448 0.082366 0.00604698 15723.5 0\n",
" : 7 Minimum Test error found - save the configuration \n",
" : 7 | 0.332185 0.634235 0.0825792 0.00611011 15692.6 0\n",
" : 8 | 0.270188 0.70119 0.0824113 0.00577826 15659 1\n",
" : 9 | 0.237262 0.744104 0.0822838 0.00574954 15679.3 2\n",
" : 10 | 0.212495 0.699014 0.0818463 0.00574415 15768.3 3\n",
" : \n",
" : Elapsed time for training with 1600 events: 0.843 sec \n",
"TMVA_DNN_CPU : [dataset] : Evaluation of TMVA_DNN_CPU on training sample (1600 events)\n",
" : Evaluate deep neural network on CPU using batches with size = 100\n",
" : \n",
"TMVA_DNN_CPU : [dataset] : Evaluation of TMVA_DNN_CPU on training sample (1600 events)\n",
" : Elapsed time for evaluation of 1600 events: 0.0293 sec \n",
" : Elapsed time for evaluation of 1600 events: 0.0312 sec \n",
" : Creating xml weight file: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_DNN_CPU.weights.xml\u001b[0m\n",
" : Creating standalone class: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_DNN_CPU.class.C\u001b[0m\n",
"Factory : Training finished\n",
" : \n",
"Factory : Train method: TMVA_CNN_CPU for Classification\n",
" : \n",
" : Start of deep neural network training on CPU using MT, nthreads = 4\n",
" : \n",
" : ***** Deep Learning Network *****\n",
"DEEP NEURAL NETWORK: Depth = 7 Input = ( 1, 16, 16 ) Batch size = 100 Loss function = C\n",
"\tLayer 0\t CONV LAYER: \t( W = 16 , H = 16 , D = 10 ) \t Filter ( W = 3 , H = 3 ) \tOutput = ( 100 , 10 , 10 , 256 ) \t Activation Function = Relu\n",
"\tLayer 1\t BATCH NORM Layer: \t Input/Output = ( 10 , 256 , 100 ) \t Norm dim = 10\t axis = 1\n",
"\n",
"\tLayer 2\t CONV LAYER: \t( W = 16 , H = 16 , D = 10 ) \t Filter ( W = 3 , H = 3 ) \tOutput = ( 100 , 10 , 10 , 256 ) \t Activation Function = Relu\n",
"\tLayer 3\t POOL Layer: \t( W = 15 , H = 15 , D = 10 ) \t Filter ( W = 2 , H = 2 ) \tOutput = ( 100 , 10 , 10 , 225 ) \n",
"\tLayer 4\t RESHAPE Layer \t Input = ( 10 , 15 , 15 ) \tOutput = ( 1 , 100 , 2250 ) \n",
"\tLayer 5\t DENSE Layer: \t ( Input = 2250 , Width = 100 ) \tOutput = ( 1 , 100 , 100 ) \t Activation Function = Relu\n",
"\tLayer 6\t DENSE Layer: \t ( Input = 100 , Width = 1 ) \tOutput = ( 1 , 100 , 1 ) \t Activation Function = Identity\n",
" : Using 1280 events for training and 320 for testing\n",
" : Compute initial loss on the validation data \n",
" : Training phase 1 of 1: Optimizer ADAM (beta1=0.9,beta2=0.999,eps=1e-07) Learning rate = 0.001 regularization 0 minimum error = 23.9967\n",
" : --------------------------------------------------------------\n",
" : Epoch | Train Err. Val. Err. t(s)/epoch t(s)/Loss nEvents/s Conv. Steps\n",
" : --------------------------------------------------------------\n",
" : Start epoch iteration ...\n",
" : 1 Minimum Test error found - save the configuration \n",
" : 1 | 5.71943 3.51573 0.755114 0.0506532 1703.43 0\n",
" : 2 Minimum Test error found - save the configuration \n",
" : 2 | 1.8996 0.836763 0.749871 0.0503842 1715.54 0\n",
" : 3 Minimum Test error found - save the configuration \n",
" : 3 | 0.947597 0.800315 0.738344 0.0503292 1744.15 0\n",
" : 4 Minimum Test error found - save the configuration \n",
" : 4 | 0.812724 0.785991 0.739496 0.0523041 1746.24 0\n",
" : 5 Minimum Test error found - save the configuration \n",
" : 5 | 0.789639 0.755527 0.744364 0.0506148 1729.73 0\n",
" : 6 Minimum Test error found - save the configuration \n",
" : 6 | 0.759565 0.736326 0.739192 0.0504021 1742.19 0\n",
" : 7 Minimum Test error found - save the configuration \n",
" : 7 | 0.724787 0.734239 0.734876 0.0505204 1753.47 0\n",
" : 8 | 0.701836 0.735194 0.751245 0.0500049 1711.26 1\n",
" : 9 | 0.671329 0.763532 0.763481 0.0527059 1688.3 2\n",
" : 10 | 0.703338 0.762887 0.762305 0.0528909 1691.54 3\n",
" : \n",
" : Elapsed time for training with 1600 events: 7.54 sec \n",
"TMVA_CNN_CPU : [dataset] : Evaluation of TMVA_CNN_CPU on training sample (1600 events)\n",
" : Evaluate deep neural network on CPU using batches with size = 100\n",
" : \n",
"TMVA_CNN_CPU : [dataset] : Evaluation of TMVA_CNN_CPU on training sample (1600 events)\n",
" : Elapsed time for evaluation of 1600 events: 0.281 sec \n",
" : Elapsed time for evaluation of 1600 events: 0.288 sec \n",
" : Creating xml weight file: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_CNN_CPU.weights.xml\u001b[0m\n",
" : Creating standalone class: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_CNN_CPU.class.C\u001b[0m\n",
"Factory : Training finished\n",
" : \n",
" : Ranking input variables (method specific)...\n",
"BDT : Ranking result (top variable is best ranked)\n",
" : --------------------------------------\n",
" : Rank : Variable : Variable Importance\n",
" : --------------------------------------\n",
" : 1 : vars : 8.757e-03\n",
" : 2 : vars : 8.222e-03\n",
" : 3 : vars : 8.111e-03\n",
" : 4 : vars : 8.043e-03\n",
" : 5 : vars : 8.005e-03\n",
" : 6 : vars : 7.971e-03\n",
" : 7 : vars : 7.450e-03\n",
" : 8 : vars : 7.303e-03\n",
" : 9 : vars : 7.146e-03\n",
" : 10 : vars : 7.050e-03\n",
" : 11 : vars : 7.021e-03\n",
" : 12 : vars : 6.946e-03\n",
" : 13 : vars : 6.906e-03\n",
" : 14 : vars : 6.884e-03\n",
" : 15 : vars : 6.710e-03\n",
" : 16 : vars : 6.632e-03\n",
" : 17 : vars : 6.576e-03\n",
" : 18 : vars : 6.561e-03\n",
" : 19 : vars : 6.513e-03\n",
" : 20 : vars : 6.502e-03\n",
" : 21 : vars : 6.476e-03\n",
" : 22 : vars : 6.356e-03\n",
" : 23 : vars : 6.319e-03\n",
" : 24 : vars : 6.303e-03\n",
" : 25 : vars : 6.285e-03\n",
" : 26 : vars : 6.219e-03\n",
" : 27 : vars : 6.205e-03\n",
" : 28 : vars : 6.191e-03\n",
" : 29 : vars : 6.182e-03\n",
" : 30 : vars : 6.167e-03\n",
" : 31 : vars : 6.143e-03\n",
" : 32 : vars : 6.075e-03\n",
" : 33 : vars : 6.070e-03\n",
" : 34 : vars : 6.033e-03\n",
" : 35 : vars : 6.030e-03\n",
" : 36 : vars : 6.014e-03\n",
" : 37 : vars : 6.001e-03\n",
" : 38 : vars : 5.946e-03\n",
" : 39 : vars : 5.899e-03\n",
" : 40 : vars : 5.898e-03\n",
" : 41 : vars : 5.886e-03\n",
" : 42 : vars : 5.826e-03\n",
" : 43 : vars : 5.816e-03\n",
" : 44 : vars : 5.749e-03\n",
" : 45 : vars : 5.676e-03\n",
" : 46 : vars : 5.660e-03\n",
" : 47 : vars : 5.643e-03\n",
" : 48 : vars : 5.597e-03\n",
" : 49 : vars : 5.595e-03\n",
" : 50 : vars : 5.578e-03\n",
" : 51 : vars : 5.572e-03\n",
" : 52 : vars : 5.529e-03\n",
" : 53 : vars : 5.493e-03\n",
" : 54 : vars : 5.468e-03\n",
" : 55 : vars : 5.453e-03\n",
" : 56 : vars : 5.381e-03\n",
" : 57 : vars : 5.375e-03\n",
" : 58 : vars : 5.353e-03\n",
" : 59 : vars : 5.342e-03\n",
" : 60 : vars : 5.324e-03\n",
" : 61 : vars : 5.276e-03\n",
" : 62 : vars : 5.252e-03\n",
" : 63 : vars : 5.246e-03\n",
" : 64 : vars : 5.164e-03\n",
" : 65 : vars : 5.087e-03\n",
" : 66 : vars : 5.069e-03\n",
" : 67 : vars : 5.057e-03\n",
" : 68 : vars : 5.032e-03\n",
" : 69 : vars : 5.022e-03\n",
" : 70 : vars : 5.003e-03\n",
" : 71 : vars : 4.995e-03\n",
" : 72 : vars : 4.910e-03\n",
" : 73 : vars : 4.881e-03\n",
" : 74 : vars : 4.841e-03\n",
" : 75 : vars : 4.838e-03\n",
" : 76 : vars : 4.801e-03\n",
" : 77 : vars : 4.797e-03\n",
" : 78 : vars : 4.790e-03\n",
" : 79 : vars : 4.773e-03\n",
" : 80 : vars : 4.748e-03\n",
" : 81 : vars : 4.744e-03\n",
" : 82 : vars : 4.665e-03\n",
" : 83 : vars : 4.659e-03\n",
" : 84 : vars : 4.647e-03\n",
" : 85 : vars : 4.645e-03\n",
" : 86 : vars : 4.637e-03\n",
" : 87 : vars : 4.621e-03\n",
" : 88 : vars : 4.607e-03\n",
" : 89 : vars : 4.607e-03\n",
" : 90 : vars : 4.604e-03\n",
" : 91 : vars : 4.598e-03\n",
" : 92 : vars : 4.584e-03\n",
" : 93 : vars : 4.568e-03\n",
" : 94 : vars : 4.563e-03\n",
" : 95 : vars : 4.491e-03\n",
" : 96 : vars : 4.473e-03\n",
" : 97 : vars : 4.447e-03\n",
" : 98 : vars : 4.433e-03\n",
" : 99 : vars : 4.433e-03\n",
" : 100 : vars : 4.424e-03\n",
" : 101 : vars : 4.397e-03\n",
" : 102 : vars : 4.383e-03\n",
" : 103 : vars : 4.381e-03\n",
" : 104 : vars : 4.356e-03\n",
" : 105 : vars : 4.336e-03\n",
" : 106 : vars : 4.311e-03\n",
" : 107 : vars : 4.298e-03\n",
" : 108 : vars : 4.273e-03\n",
" : 109 : vars : 4.244e-03\n",
" : 110 : vars : 4.226e-03\n",
" : 111 : vars : 4.218e-03\n",
" : 112 : vars : 4.216e-03\n",
" : 113 : vars : 4.168e-03\n",
" : 114 : vars : 4.153e-03\n",
" : 115 : vars : 4.138e-03\n",
" : 116 : vars : 4.109e-03\n",
" : 117 : vars : 4.076e-03\n",
" : 118 : vars : 4.062e-03\n",
" : 119 : vars : 4.057e-03\n",
" : 120 : vars : 4.026e-03\n",
" : 121 : vars : 4.015e-03\n",
" : 122 : vars : 4.002e-03\n",
" : 123 : vars : 3.981e-03\n",
" : 124 : vars : 3.969e-03\n",
" : 125 : vars : 3.931e-03\n",
" : 126 : vars : 3.922e-03\n",
" : 127 : vars : 3.917e-03\n",
" : 128 : vars : 3.890e-03\n",
" : 129 : vars : 3.885e-03\n",
" : 130 : vars : 3.856e-03\n",
" : 131 : vars : 3.841e-03\n",
" : 132 : vars : 3.811e-03\n",
" : 133 : vars : 3.809e-03\n",
" : 134 : vars : 3.809e-03\n",
" : 135 : vars : 3.804e-03\n",
" : 136 : vars : 3.787e-03\n",
" : 137 : vars : 3.783e-03\n",
" : 138 : vars : 3.762e-03\n",
" : 139 : vars : 3.759e-03\n",
" : 140 : vars : 3.751e-03\n",
" : 141 : vars : 3.740e-03\n",
" : 142 : vars : 3.710e-03\n",
" : 143 : vars : 3.707e-03\n",
" : 144 : vars : 3.701e-03\n",
" : 145 : vars : 3.688e-03\n",
" : 146 : vars : 3.684e-03\n",
" : 147 : vars : 3.675e-03\n",
" : 148 : vars : 3.672e-03\n",
" : 149 : vars : 3.666e-03\n",
" : 150 : vars : 3.665e-03\n",
" : 151 : vars : 3.664e-03\n",
" : 152 : vars : 3.650e-03\n",
" : 153 : vars : 3.612e-03\n",
" : 154 : vars : 3.536e-03\n",
" : 155 : vars : 3.525e-03\n",
" : 156 : vars : 3.523e-03\n",
" : 157 : vars : 3.497e-03\n",
" : 158 : vars : 3.478e-03\n",
" : 159 : vars : 3.476e-03\n",
" : 160 : vars : 3.471e-03\n",
" : 161 : vars : 3.409e-03\n",
" : 162 : vars : 3.399e-03\n",
" : 163 : vars : 3.392e-03\n",
" : 164 : vars : 3.354e-03\n",
" : 165 : vars : 3.341e-03\n",
" : 166 : vars : 3.313e-03\n",
" : 167 : vars : 3.288e-03\n",
" : 168 : vars : 3.248e-03\n",
" : 169 : vars : 3.242e-03\n",
" : 170 : vars : 3.207e-03\n",
" : 171 : vars : 3.200e-03\n",
" : 172 : vars : 3.130e-03\n",
" : 173 : vars : 3.129e-03\n",
" : 174 : vars : 3.128e-03\n",
" : 175 : vars : 3.120e-03\n",
" : 176 : vars : 3.072e-03\n",
" : 177 : vars : 3.045e-03\n",
" : 178 : vars : 2.979e-03\n",
" : 179 : vars : 2.931e-03\n",
" : 180 : vars : 2.927e-03\n",
" : 181 : vars : 2.914e-03\n",
" : 182 : vars : 2.912e-03\n",
" : 183 : vars : 2.889e-03\n",
" : 184 : vars : 2.855e-03\n",
" : 185 : vars : 2.852e-03\n",
" : 186 : vars : 2.847e-03\n",
" : 187 : vars : 2.831e-03\n",
" : 188 : vars : 2.819e-03\n",
" : 189 : vars : 2.817e-03\n",
" : 190 : vars : 2.803e-03\n",
" : 191 : vars : 2.800e-03\n",
" : 192 : vars : 2.791e-03\n",
" : 193 : vars : 2.785e-03\n",
" : 194 : vars : 2.773e-03\n",
" : 195 : vars : 2.712e-03\n",
" : 196 : vars : 2.694e-03\n",
" : 197 : vars : 2.671e-03\n",
" : 198 : vars : 2.670e-03\n",
" : 199 : vars : 2.662e-03\n",
" : 200 : vars : 2.651e-03\n",
" : 201 : vars : 2.591e-03\n",
" : 202 : vars : 2.583e-03\n",
" : 203 : vars : 2.577e-03\n",
" : 204 : vars : 2.568e-03\n",
" : 205 : vars : 2.544e-03\n",
" : 206 : vars : 2.451e-03\n",
" : 207 : vars : 2.431e-03\n",
" : 208 : vars : 2.427e-03\n",
" : 209 : vars : 2.413e-03\n",
" : 210 : vars : 2.403e-03\n",
" : 211 : vars : 2.371e-03\n",
" : 212 : vars : 2.306e-03\n",
" : 213 : vars : 2.295e-03\n",
" : 214 : vars : 2.288e-03\n",
" : 215 : vars : 2.277e-03\n",
" : 216 : vars : 2.277e-03\n",
" : 217 : vars : 2.133e-03\n",
" : 218 : vars : 2.022e-03\n",
" : 219 : vars : 1.952e-03\n",
" : 220 : vars : 1.939e-03\n",
" : 221 : vars : 1.930e-03\n",
" : 222 : vars : 1.868e-03\n",
" : 223 : vars : 1.842e-03\n",
" : 224 : vars : 1.800e-03\n",
" : 225 : vars : 1.797e-03\n",
" : 226 : vars : 1.793e-03\n",
" : 227 : vars : 1.745e-03\n",
" : 228 : vars : 1.674e-03\n",
" : 229 : vars : 1.649e-03\n",
" : 230 : vars : 1.590e-03\n",
" : 231 : vars : 1.585e-03\n",
" : 232 : vars : 1.574e-03\n",
" : 233 : vars : 1.548e-03\n",
" : 234 : vars : 1.314e-03\n",
" : 235 : vars : 1.264e-03\n",
" : 236 : vars : 1.105e-03\n",
" : 237 : vars : 1.091e-03\n",
" : 238 : vars : 9.970e-04\n",
" : 239 : vars : 8.583e-04\n",
" : 240 : vars : 0.000e+00\n",
" : 241 : vars : 0.000e+00\n",
" : 242 : vars : 0.000e+00\n",
" : 243 : vars : 0.000e+00\n",
" : 244 : vars : 0.000e+00\n",
" : 245 : vars : 0.000e+00\n",
" : 246 : vars : 0.000e+00\n",
" : 247 : vars : 0.000e+00\n",
" : 248 : vars : 0.000e+00\n",
" : 249 : vars : 0.000e+00\n",
" : 250 : vars : 0.000e+00\n",
" : 251 : vars : 0.000e+00\n",
" : 252 : vars : 0.000e+00\n",
" : 253 : vars : 0.000e+00\n",
" : 254 : vars : 0.000e+00\n",
" : 255 : vars : 0.000e+00\n",
" : 256 : vars : 0.000e+00\n",
" : --------------------------------------\n",
" : No variable ranking supplied by classifier: TMVA_DNN_CPU\n",
" : No variable ranking supplied by classifier: TMVA_CNN_CPU\n",
"TH1.Print Name = TrainingHistory_TMVA_DNN_CPU_trainingError, Entries= 0, Total sum= 4.62627\n",
"TH1.Print Name = TrainingHistory_TMVA_DNN_CPU_valError, Entries= 0, Total sum= 7.61981\n",
"TH1.Print Name = TrainingHistory_TMVA_CNN_CPU_trainingError, Entries= 0, Total sum= 13.7298\n",
"TH1.Print Name = TrainingHistory_TMVA_CNN_CPU_valError, Entries= 0, Total sum= 10.4265\n",
"Factory : === Destroy and recreate all methods via weight files for testing ===\n",
" : \n",
" : Reading weight file: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_BDT.weights.xml\u001b[0m\n",
" : Reading weight file: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_DNN_CPU.weights.xml\u001b[0m\n",
" : Reading weight file: \u001b[0;36mdataset/weights/TMVA_CNN_Classification_TMVA_CNN_CPU.weights.xml\u001b[0m\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"0%, time left: unknown\n",
"6%, time left: 1 sec\n",
"12%, time left: 1 sec\n",
"19%, time left: 1 sec\n",
"25%, time left: 0 sec\n",
"31%, time left: 0 sec\n",
"37%, time left: 0 sec\n",
"44%, time left: 0 sec\n",
"50%, time left: 0 sec\n",
"56%, time left: 0 sec\n",
"62%, time left: 0 sec\n",
"69%, time left: 0 sec\n",
"75%, time left: 0 sec\n",
"81%, time left: 0 sec\n",
"87%, time left: 0 sec\n",
"94%, time left: 0 sec\n",
"0%, time left: unknown\n",
"7%, time left: 0 sec\n",
"13%, time left: 0 sec\n",
"19%, time left: 0 sec\n",
"25%, time left: 0 sec\n",
"32%, time left: 0 sec\n",
"38%, time left: 0 sec\n",
"44%, time left: 0 sec\n",
"50%, time left: 0 sec\n",
"57%, time left: 0 sec\n",
"63%, time left: 0 sec\n",
"69%, time left: 0 sec\n",
"75%, time left: 0 sec\n",
"82%, time left: 0 sec\n",
"88%, time left: 0 sec\n",
"94%, time left: 0 sec\n"
]
}
],
"source": [
"factory.TrainAllMethods()"
]
},
{
"cell_type": "markdown",
"id": "35ea4729",
"metadata": {},
"source": [
" Test and Evaluate Methods"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "e0733735",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:23:03.700212Z",
"iopub.status.busy": "2026-05-19T20:23:03.700089Z",
"iopub.status.idle": "2026-05-19T20:23:05.078643Z",
"shell.execute_reply": "2026-05-19T20:23:05.077483Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Factory : \u001b[1mTest all methods\u001b[0m\n",
"Factory : Test method: BDT for Classification performance\n",
" : \n",
"BDT : [dataset] : Evaluation of BDT on testing sample (400 events)\n",
"BDT : [dataset] : Evaluation of BDT on testing sample (400 events)\n",
" : Elapsed time for evaluation of 400 events: 0.00357 sec \n",
" : Elapsed time for evaluation of 400 events: 0.00368 sec \n",
"Factory : Test method: TMVA_DNN_CPU for Classification performance\n",
" : \n",
"TMVA_DNN_CPU : [dataset] : Evaluation of TMVA_DNN_CPU on testing sample (400 events)\n",
" : Evaluate deep neural network on CPU using batches with size = 400\n",
" : \n",
"TMVA_DNN_CPU : [dataset] : Evaluation of TMVA_DNN_CPU on testing sample (400 events)\n",
" : Elapsed time for evaluation of 400 events: 0.0069 sec \n",
" : Elapsed time for evaluation of 400 events: 0.00879 sec \n",
"Factory : Test method: TMVA_CNN_CPU for Classification performance\n",
" : \n",
"TMVA_CNN_CPU : [dataset] : Evaluation of TMVA_CNN_CPU on testing sample (400 events)\n",
" : Evaluate deep neural network on CPU using batches with size = 400\n",
" : \n",
"TMVA_CNN_CPU : [dataset] : Evaluation of TMVA_CNN_CPU on testing sample (400 events)\n",
" : Elapsed time for evaluation of 400 events: 0.0701 sec \n",
" : Elapsed time for evaluation of 400 events: 0.0799 sec \n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"0%, time left: unknown\n",
"7%, time left: 0 sec\n",
"13%, time left: 0 sec\n",
"19%, time left: 0 sec\n",
"25%, time left: 0 sec\n",
"32%, time left: 0 sec\n",
"38%, time left: 0 sec\n",
"44%, time left: 0 sec\n",
"50%, time left: 0 sec\n",
"57%, time left: 0 sec\n",
"63%, time left: 0 sec\n",
"69%, time left: 0 sec\n",
"75%, time left: 0 sec\n",
"82%, time left: 0 sec\n",
"88%, time left: 0 sec\n",
"94%, time left: 0 sec\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Factory : \u001b[1mEvaluate all methods\u001b[0m\n",
"Factory : Evaluate classifier: BDT\n",
" : \n",
"BDT : [dataset] : Loop over test events and fill histograms with classifier response...\n",
" : \n",
" : Dataset[dataset] : variable plots are not produces ! The number of variables is 256 , it is larger than 200\n",
"Factory : Evaluate classifier: TMVA_DNN_CPU\n",
" : \n",
"TMVA_DNN_CPU : [dataset] : Loop over test events and fill histograms with classifier response...\n",
" : \n",
" : Evaluate deep neural network on CPU using batches with size = 1000\n",
" : \n",
" : Dataset[dataset] : variable plots are not produces ! The number of variables is 256 , it is larger than 200\n",
"Factory : Evaluate classifier: TMVA_CNN_CPU\n",
" : \n",
"TMVA_CNN_CPU : [dataset] : Loop over test events and fill histograms with classifier response...\n",
" : \n",
" : Evaluate deep neural network on CPU using batches with size = 1000\n",
" : \n",
" : Dataset[dataset] : variable plots are not produces ! The number of variables is 256 , it is larger than 200\n",
" : \n",
" : Evaluation results ranked by best signal efficiency and purity (area)\n",
" : -------------------------------------------------------------------------------------------------------------------\n",
" : DataSet MVA \n",
" : Name: Method: ROC-integ\n",
" : dataset BDT : 0.769\n",
" : dataset TMVA_DNN_CPU : 0.700\n",
" : dataset TMVA_CNN_CPU : 0.582\n",
" : -------------------------------------------------------------------------------------------------------------------\n",
" : \n",
" : Testing efficiency compared to training efficiency (overtraining check)\n",
" : -------------------------------------------------------------------------------------------------------------------\n",
" : DataSet MVA Signal efficiency: from test sample (from training sample) \n",
" : Name: Method: @B=0.01 @B=0.10 @B=0.30 \n",
" : -------------------------------------------------------------------------------------------------------------------\n",
" : dataset BDT : 0.075 (0.425) 0.465 (0.691) 0.683 (0.862)\n",
" : dataset TMVA_DNN_CPU : 0.035 (0.195) 0.315 (0.535) 0.565 (0.841)\n",
" : dataset TMVA_CNN_CPU : 0.020 (0.022) 0.185 (0.216) 0.425 (0.464)\n",
" : -------------------------------------------------------------------------------------------------------------------\n",
" : \n",
"Dataset:dataset : Created tree 'TestTree' with 400 events\n",
" : \n",
"Dataset:dataset : Created tree 'TrainTree' with 1600 events\n",
" : \n",
"Factory : \u001b[1mThank you for using TMVA!\u001b[0m\n",
" : \u001b[1mFor citation information, please visit: http://tmva.sf.net/citeTMVA.html\u001b[0m\n"
]
}
],
"source": [
"factory.TestAllMethods()\n",
"\n",
"factory.EvaluateAllMethods()"
]
},
{
"cell_type": "markdown",
"id": "7c6b0614",
"metadata": {},
"source": [
" Plot ROC Curve"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "d4a713d4",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:23:05.080167Z",
"iopub.status.busy": "2026-05-19T20:23:05.080046Z",
"iopub.status.idle": "2026-05-19T20:23:05.298196Z",
"shell.execute_reply": "2026-05-19T20:23:05.297355Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"c1 = factory.GetROCCurve(loader)\n",
"c1.Draw()"
]
},
{
"cell_type": "markdown",
"id": "74bc6308",
"metadata": {},
"source": [
"close outputfile to save output file"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "1bae1786",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:23:05.299482Z",
"iopub.status.busy": "2026-05-19T20:23:05.299360Z",
"iopub.status.idle": "2026-05-19T20:23:05.409886Z",
"shell.execute_reply": "2026-05-19T20:23:05.409208Z"
}
},
"outputs": [],
"source": [
"outputFile.Close()"
]
},
{
"cell_type": "markdown",
"id": "4c9472c1",
"metadata": {},
"source": [
"Draw all canvases "
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "960ce2f4",
"metadata": {
"collapsed": false,
"execution": {
"iopub.execute_input": "2026-05-19T20:23:05.411617Z",
"iopub.status.busy": "2026-05-19T20:23:05.411481Z",
"iopub.status.idle": "2026-05-19T20:23:05.524207Z",
"shell.execute_reply": "2026-05-19T20:23:05.523543Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from ROOT import gROOT \n",
"gROOT.GetListOfCanvases().Draw()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.12"
}
},
"nbformat": 4,
"nbformat_minor": 5
}