CombinationExpert Class Reference

Expert for the Combination MVA method. More...

#include <Combination.h>

Inheritance diagram for CombinationExpert:

Collaboration diagram for CombinationExpert:

Public Member Functions
virtual void	load (Weightfile &weightfile) override
	Load the expert from a Weightfile.
virtual std::vector< float >	apply (Dataset &test_data) const override
	Apply this expert onto a dataset.
virtual std::vector< std::vector< float > >	applyMulticlass (Dataset &test_data) const
	Apply this m_expert onto a dataset.

Protected Attributes
GeneralOptions	m_general_options
	General options loaded from the weightfile.

Private Attributes
CombinationOptions	m_specific_options
	Method specific options.
std::vector< std::unique_ptr< Expert > >	m_experts
	Experts of the methods to combine.
std::vector< std::vector< std::string > >	m_expert_variables
	Results of the experts to combine.

Detailed Description

Expert for the Combination MVA method.

Definition at line 83 of file Combination.h.

Member Function Documentation

apply()

std::vector< float > apply ( Dataset &  test_data ) const

overridevirtual

Apply this expert onto a dataset.

Parameters

test_data

dataset

Implements Expert.

Definition at line 105 of file Combination.cc.

    {
      std::vector<float> probabilities(test_data.getNumberOfEvents(), 0);
      std::vector<std::vector<float>> expert_probabilities;
 
      for (unsigned int iExpert = 0; iExpert < m_experts.size(); ++iExpert) {
        GeneralOptions sub_general_options = m_general_options;
        sub_general_options.m_variables = m_expert_variables[iExpert];
        SubDataset sub_dataset(sub_general_options, {}, test_data);
        expert_probabilities.push_back(m_experts[iExpert]->apply(sub_dataset));
      }
 
      for (unsigned int iEvent = 0; iEvent < test_data.getNumberOfEvents(); ++iEvent) {
        double a = 1.0;
        double b = 1.0;
        for (unsigned int iExpert = 0; iExpert < m_experts.size(); ++iExpert) {
          a *= expert_probabilities[iExpert][iEvent];
          b *= (1.0 - expert_probabilities[iExpert][iEvent]);
        }
        probabilities[iEvent] = a / (a + b);
      }
      return probabilities;
    }

applyMulticlass()

virtual std::vector< std::vector< float > > applyMulticlass ( Dataset &  test_data ) const

inlinevirtualinherited

Apply this m_expert onto a dataset.

Multiclass mode. Not pure virtual, since not all derived classes to re-implement this.

Parameters

test_data

dataset.

Returns

vector of size N=test_data.getNumberOfEvents() with N=m_classes.size() scores for each event in the dataset.

Reimplemented in PythonExpert, TMVAExpertMulticlass, and TrivialExpert.

Definition at line 56 of file Expert.h.

      {
 
        B2ERROR("Attempted to call applyMulticlass() of the abstract base class MVA::Expert. All methods that support multiclass classification should override this definition.");
        (void) test_data;
 
        return std::vector<std::vector<float>>();
      };

load()

void load ( Weightfile &  weightfile )

overridevirtual

Load the expert from a Weightfile.

Parameters

weightfile

containing all information necessary to build the expert

Implements Expert.

Definition at line 77 of file Combination.cc.

    {
 
      weightfile.getOptions(m_specific_options);
 
      m_experts.clear();
      m_expert_variables.clear();
 
      for (unsigned int i = 0; i < m_specific_options.m_weightfiles.size(); ++i) {
        std::string sub_weightfile_name = weightfile.generateFileName(".xml");
        weightfile.getFile("Combination_Weightfile" +  std::to_string(i), sub_weightfile_name);
        auto sub_weightfile = Weightfile::load(sub_weightfile_name);
        GeneralOptions general_options;
        sub_weightfile.getOptions(general_options);
 
        AbstractInterface::initSupportedInterfaces();
        auto supported_interfaces = AbstractInterface::getSupportedInterfaces();
        if (supported_interfaces.find(general_options.m_method) == supported_interfaces.end()) {
          B2ERROR("Couldn't find method named " + general_options.m_method);
          throw std::runtime_error("Couldn't find method named " + general_options.m_method);
        }
        auto expert = supported_interfaces[general_options.m_method]->getExpert();
        expert->load(sub_weightfile);
        m_experts.emplace_back(std::move(expert));
        m_expert_variables.push_back(general_options.m_variables);
      }
    }

Member Data Documentation

m_expert_variables

std::vector<std::vector<std::string> > m_expert_variables

private

Results of the experts to combine.

Definition at line 101 of file Combination.h.

m_experts

std::vector<std::unique_ptr<Expert> > m_experts

private

Experts of the methods to combine.

Definition at line 100 of file Combination.h.

m_general_options

GeneralOptions m_general_options

protectedinherited

General options loaded from the weightfile.

Definition at line 70 of file Expert.h.

m_specific_options

CombinationOptions m_specific_options

private

Method specific options.

Definition at line 99 of file Combination.h.

---

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

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