TMVATeacherClassification Class Reference

Teacher for the TMVA Classification MVA method. More...

#include <TMVA.h>

Inheritance diagram for TMVATeacherClassification:

Collaboration diagram for TMVATeacherClassification:

Public Member Functions
	TMVATeacherClassification (const GeneralOptions &general_options, const TMVAOptionsClassification &_specific_options)
	Constructs a new teacher using the GeneralOptions and specific options of this training.
virtual Weightfile	train (Dataset &training_data) const override
	Train a mva method using the given dataset returning a Weightfile.
Weightfile	trainFactory (TMVA::Factory &factory, TMVA::DataLoader &data_loader, const std::string &jobName) const
	Train a mva method using the given data loader returning a Weightfile.

Protected Attributes
TMVAOptionsClassification	specific_options
	Method specific options.
GeneralOptions	m_general_options
	GeneralOptions containing all shared options.

Detailed Description

Teacher for the TMVA Classification MVA method.

Definition at line 214 of file TMVA.h.

Constructor & Destructor Documentation

TMVATeacherClassification()

TMVATeacherClassification	(	const GeneralOptions &	general_options,
		const TMVAOptionsClassification &	_specific_options
	)

Constructs a new teacher using the GeneralOptions and specific options of this training.

Parameters

general_options	defining all shared options
_specific_options	defining all method specific options

Definition at line 203 of file TMVA.cc.

                                                                                                             : TMVATeacher(general_options, _specific_options),
      specific_options(_specific_options) { }

Member Function Documentation

train()

Weightfile train ( Dataset &  training_data ) const

overridevirtual

Train a mva method using the given dataset returning a Weightfile.

Parameters

training_data

used to train the method

Implements Teacher.

Definition at line 207 of file TMVA.cc.

    {
 
      unsigned int numberOfFeatures = training_data.getNumberOfFeatures();
      unsigned int numberOfSpectators = training_data.getNumberOfSpectators();
      unsigned int numberOfEvents = training_data.getNumberOfEvents();
 
      std::string directory = specific_options.m_workingDirectory;
      if (specific_options.m_workingDirectory.empty()) {
        char* directory_template = strdup((std::filesystem::temp_directory_path() / "Basf2TMVA.XXXXXX").c_str());
        directory = mkdtemp(directory_template);
        free(directory_template);
      }
 
      // cppcheck-suppress unreadVariable
      auto guard = ScopeGuard::guardWorkingDirectory(directory);
 
      std::string jobName = specific_options.m_prefix;
      if (jobName.empty())
        jobName = "TMVA";
      TFile classFile((jobName + ".root").c_str(), "RECREATE");
      classFile.cd();
 
      TMVA::Tools::Instance();
      TMVA::DataLoader data_loader(jobName);
      TMVA::Factory factory(jobName, &classFile, specific_options.m_factoryOption);
 
 
      // Add variables to the factory
      for (auto& var : m_general_options.m_variables) {
        data_loader.AddVariable(Belle2::MakeROOTCompatible::makeROOTCompatible(var));
      }
 
      // Add variables to the factory
      for (auto& var : m_general_options.m_spectators) {
        data_loader.AddSpectator(Belle2::MakeROOTCompatible::makeROOTCompatible(var));
      }
 
      data_loader.SetWeightExpression(Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_weight_variable));
 
      auto* signal_tree = new TTree("signal_tree", "signal_tree");
      auto* background_tree = new TTree("background_tree", "background_tree");
 
      for (unsigned int iFeature = 0; iFeature < numberOfFeatures; ++iFeature) {
        signal_tree->Branch(Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_variables[iFeature]).c_str(),
                            &training_data.m_input[iFeature]);
        background_tree->Branch(Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_variables[iFeature]).c_str(),
                                &training_data.m_input[iFeature]);
      }
 
      for (unsigned int iSpectator = 0; iSpectator < numberOfSpectators; ++iSpectator) {
        signal_tree->Branch(Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_spectators[iSpectator]).c_str(),
                            &training_data.m_spectators[iSpectator]);
        background_tree->Branch(Belle2::MakeROOTCompatible::makeROOTCompatible(m_general_options.m_spectators[iSpectator]).c_str(),
                                &training_data.m_spectators[iSpectator]);
      }
 
      signal_tree->Branch("__weight__", &training_data.m_weight);
      background_tree->Branch("__weight__", &training_data.m_weight);
 
      for (unsigned int iEvent = 0; iEvent < numberOfEvents; ++iEvent) {
        training_data.loadEvent(iEvent);
        if (training_data.m_isSignal) {
          signal_tree->Fill();
        } else {
          background_tree->Fill();
        }
      }
 
      data_loader.AddSignalTree(signal_tree);
      data_loader.AddBackgroundTree(background_tree);
      auto weightfile = trainFactory(factory, data_loader, jobName);
 
      weightfile.addOptions(specific_options);
      weightfile.addSignalFraction(training_data.getSignalFraction());
 
      delete signal_tree;
      delete background_tree;
 
      if (specific_options.m_workingDirectory.empty()) {
        std::filesystem::remove_all(directory);
      }
 
      return weightfile;
 
    }

trainFactory()

Weightfile trainFactory ( TMVA::Factory &  factory, TMVA::DataLoader &  data_loader, const std::string &  jobName  ) const

inherited

Train a mva method using the given data loader returning a Weightfile.

Parameters

factory	used to train the method
data_loader	used to train the method
jobName	name of the TMVA training

Definition at line 122 of file TMVA.cc.

    {
      data_loader.PrepareTrainingAndTestTree("", specific_options.m_prepareOption);
 
      if (specific_options.m_type == "Plugins") {
        auto base = std::string("TMVA@@MethodBase");
        auto regexp1 = std::string(".*_") + specific_options.m_method + std::string(".*");
        auto regexp2 = std::string(".*") + specific_options.m_method + std::string(".*");
        auto className = std::string("TMVA::Method") + specific_options.m_method;
        auto ctor1 = std::string("Method") + specific_options.m_method + std::string("(TMVA::DataSetInfo&,TString)");
        auto ctor2 = std::string("Method") + specific_options.m_method + std::string("(TString&,TString&,TMVA::DataSetInfo&,TString&)");
        auto pluginName = std::string("TMVA") + specific_options.m_method;
 
        gROOT->GetPluginManager()->AddHandler(base.c_str(), regexp1.c_str(), className.c_str(), pluginName.c_str(), ctor1.c_str());
        gROOT->GetPluginManager()->AddHandler(base.c_str(), regexp2.c_str(), className.c_str(), pluginName.c_str(), ctor2.c_str());
      }
 
      if (!factory.BookMethod(&data_loader, specific_options.m_type, specific_options.m_method, specific_options.m_config)) {
        B2ERROR("TMVA Method with name " + specific_options.m_method + " cannot be booked.");
      }
 
      Weightfile weightfile;
      std::string logfilename = weightfile.generateFileName(".log");
 
      // Pipe stdout into a logfile to get TMVA output, which contains valuable information
      // which cannot be retrieved otherwise!
      // Hence we do some black magic here
      // TODO Using ROOT_VERSION 6.08  this should be possible without this workaround
      auto logfile = open(logfilename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
      auto saved_stdout = dup(STDOUT_FILENO);
      dup2(logfile, 1);
 
      factory.TrainAllMethods();
      factory.TestAllMethods();
      factory.EvaluateAllMethods();
 
      // Reset original output
      dup2(saved_stdout, STDOUT_FILENO);
      close(saved_stdout);
      close(logfile);
 
 
      weightfile.addOptions(m_general_options);
      weightfile.addFile("TMVA_Weightfile", std::string("TMVA/weights/") + jobName + "_" + specific_options.m_method + ".weights.xml");
      weightfile.addFile("TMVA_Logfile", logfilename);
 
      // We have to parse the TMVA output to get the feature importances, there is no other way currently
      std::string begin = "Ranking input variables (method specific)";
      std::string end = "-----------------------------------";
      std::string line;
      std::ifstream file(logfilename, std::ios::in);
      std::map<std::string, float> feature_importances;
      int state = 0;
      while (std::getline(file, line)) {
        if (state == 0 && line.find(begin) != std::string::npos) {
          state = 1;
          continue;
        }
        if (state >= 1 and state <= 4) {
          state++;
          continue;
        }
        if (state == 5) {
          if (line.find(end) != std::string::npos)
            break;
          std::vector<std::string> strs;
          boost::split(strs, line, boost::is_any_of(":"));
          std::string variable = strs[2];
          boost::trim(variable);
          variable = Belle2::MakeROOTCompatible::invertMakeROOTCompatible(variable);
          float importance = std::stof(strs[3]);
          feature_importances[variable] = importance;
        }
      }
      weightfile.addFeatureImportance(feature_importances);
 
      return weightfile;
 
    }

Member Data Documentation

m_general_options

GeneralOptions m_general_options

protectedinherited

GeneralOptions containing all shared options.

Definition at line 49 of file Teacher.h.

specific_options

TMVAOptionsClassification specific_options

protected

Method specific options.

Definition at line 231 of file TMVA.h.

---

The documentation for this class was generated from the following files:

• mva/methods/include/TMVA.h
• mva/methods/src/TMVA.cc