ReweighterExpert Class Reference

Expert for the Reweighter MVA method. More...

#include <Reweighter.h>

Inheritance diagram for ReweighterExpert:

Collaboration diagram for ReweighterExpert:

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
ReweighterOptions	m_specific_options
	Method specific options.
GeneralOptions	m_expert_options
	Method general options of the expert.
std::unique_ptr< Expert >	m_expert
	Experts used to reweight.
double	m_norm = 0.0
	Norm for the weights.

Detailed Description

Expert for the Reweighter MVA method.

Definition at line 84 of file Reweighter.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 176 of file Reweighter.cc.

    {
      auto prediction = m_expert->apply(test_data);
 
      if (m_specific_options.m_variable != "") {
        auto variable = test_data.getSpectator(test_data.getSpectatorIndex(m_specific_options.m_variable));
 
        for (unsigned int iEvent = 0; iEvent < test_data.getNumberOfEvents(); ++iEvent) {
          if (variable[iEvent] != 1.0) {
            prediction[iEvent] = 1.0;
          } else {
            if (prediction[iEvent] > 0.995)
              prediction[iEvent] = 0.995;
            if (prediction[iEvent] < 0.005)
              prediction[iEvent] = 0.005;
 
            prediction[iEvent] = (prediction[iEvent]) / (1 - prediction[iEvent]);
            prediction[iEvent] /= m_norm;
          }
        }
      } else {
        for (unsigned int iEvent = 0; iEvent < test_data.getNumberOfEvents(); ++iEvent) {
          if (prediction[iEvent] > 0.995)
            prediction[iEvent] = 0.995;
          if (prediction[iEvent] < 0.005)
            prediction[iEvent] = 0.005;
 
          prediction[iEvent] = (prediction[iEvent]) / (1 - prediction[iEvent]);
          prediction[iEvent] /= m_norm;
        }
      }
 
      return prediction;
 
    }

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 154 of file Reweighter.cc.

    {
 
      weightfile.getOptions(m_specific_options);
 
      std::string sub_weightfile_name = weightfile.generateFileName(".xml");
      weightfile.getFile("Reweighter_Weightfile", sub_weightfile_name);
      auto sub_weightfile = Weightfile::load(sub_weightfile_name);
      sub_weightfile.getOptions(m_expert_options);
 
      AbstractInterface::initSupportedInterfaces();
      auto supported_interfaces = AbstractInterface::getSupportedInterfaces();
      if (supported_interfaces.find(m_expert_options.m_method) == supported_interfaces.end()) {
        B2ERROR("Couldn't find method named " + m_expert_options.m_method);
        throw std::runtime_error("Couldn't find method named " + m_expert_options.m_method);
      }
      m_expert = supported_interfaces[m_expert_options.m_method]->getExpert();
      m_expert->load(sub_weightfile);
 
      m_norm = weightfile.getElement<float>("Reweighter_norm");
    }

Member Data Documentation

m_expert

std::unique_ptr<Expert> m_expert

private

Experts used to reweight.

Definition at line 102 of file Reweighter.h.

m_expert_options

GeneralOptions m_expert_options

private

Method general options of the expert.

Definition at line 101 of file Reweighter.h.

m_general_options

GeneralOptions m_general_options

protectedinherited

General options loaded from the weightfile.

Definition at line 70 of file Expert.h.

m_norm

double m_norm = 0.0

private

Norm for the weights.

Definition at line 103 of file Reweighter.h.

m_specific_options

ReweighterOptions m_specific_options

private

Method specific options.

Definition at line 100 of file Reweighter.h.

---

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

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