TMVATeacherMulticlass Class Reference

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

#include <TMVA.h>

Inheritance diagram for TMVATeacherMulticlass:

Public Member Functions
	TMVATeacherMulticlass (const GeneralOptions &general_options, const TMVAOptionsMulticlass &_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
TMVAOptionsMulticlass	specific_options
	Method specific options.
GeneralOptions	m_general_options
	GeneralOptions containing all shared options.

Detailed Description

Teacher for the TMVA Multiclass MVA method.

Definition at line 237 of file TMVA.h.

Constructor & Destructor Documentation

TMVATeacherMulticlass()

TMVATeacherMulticlass	(	const GeneralOptions &	general_options,
		const TMVAOptionsMulticlass &	_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 294 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 299 of file TMVA.cc.

    {
      B2ERROR("Training TMVAMulticlass classifiers within the MVA package has not been implemented yet.");
      (void) training_data;
      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

TMVAOptionsMulticlass specific_options

protected

Method specific options.

Definition at line 254 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