PythonExpert Class Reference

Expert for the Python MVA method. More...

#include <Python.h>

Inheritance diagram for PythonExpert:

Public Member Functions
	PythonExpert ()
	Constructs a new Python Expert.
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 override
	Apply this expert onto a dataset for multiclass problem.

Protected Attributes
PythonOptions	m_specific_options
	Method specific options.
boost::python::object	m_unique_mva_module
	python module containing the mva methods
boost::python::object	m_state
	current state object of method
std::vector< float >	m_means
	Means of all features for normalization.
std::vector< float >	m_stds
	Stds of all features for normalization.
GeneralOptions	m_general_options
	General options loaded from the weightfile.

Detailed Description

Expert for the Python MVA method.

Definition at line 111 of file Python.h.

Constructor & Destructor Documentation

PythonExpert()

PythonExpert

(

)

Constructs a new Python Expert.

Definition at line 402 of file Python.cc.

    {
      PythonInitializerSingleton::GetInstance();
    }

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 462 of file Python.cc.

    {
 
      uint64_t numberOfFeatures = test_data.getNumberOfFeatures();
      uint64_t numberOfEvents = test_data.getNumberOfEvents();
 
      auto X = std::unique_ptr<float[]>(new float[numberOfEvents * numberOfFeatures]);
      npy_intp dimensions_X[2] = {static_cast<npy_intp>(numberOfEvents), static_cast<npy_intp>(numberOfFeatures)};
 
      for (uint64_t iEvent = 0; iEvent < numberOfEvents; ++iEvent) {
        test_data.loadEvent(iEvent);
        if (m_specific_options.m_normalize) {
          for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
            X[iEvent * numberOfFeatures + iFeature] = (test_data.m_input[iFeature] - m_means[iFeature]) / m_stds[iFeature];
        } else {
          for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
            X[iEvent * numberOfFeatures + iFeature] = test_data.m_input[iFeature];
        }
      }
 
      std::vector<float> probabilities(test_data.getNumberOfEvents(), std::numeric_limits<float>::quiet_NaN());
 
      try {
        auto ndarray_X = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_X, NPY_FLOAT32, X.get()));
        auto result = m_unique_mva_module.attr("apply")(m_state, ndarray_X);
        for (uint64_t iEvent = 0; iEvent < numberOfEvents; ++iEvent) {
          // We have to do some nasty casting here, because the Python C-Api uses structs which are binary compatible
          // to a PyObject but do not inherit from it!
          probabilities[iEvent] = static_cast<float>(*static_cast<float*>(PyArray_GETPTR1(reinterpret_cast<PyArrayObject*>(result.ptr()),
                                                     iEvent)));
        }
      } catch (...) {
        PyErr_Print();
        PyErr_Clear();
        B2ERROR("Failed calling applying PythonExpert");
        throw std::runtime_error("Failed calling applying PythonExpert");
      }
 
      return probabilities;
    }

applyMulticlass()

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

overridevirtual

Apply this expert onto a dataset for multiclass problem.

Parameters

test_data

dataset

Reimplemented from Expert.

Definition at line 503 of file Python.cc.

    {
 
      uint64_t numberOfFeatures = test_data.getNumberOfFeatures();
      uint64_t numberOfEvents = test_data.getNumberOfEvents();
 
      auto X = std::unique_ptr<float[]>(new float[numberOfEvents * numberOfFeatures]);
      npy_intp dimensions_X[2] = {static_cast<npy_intp>(numberOfEvents), static_cast<npy_intp>(numberOfFeatures)};
 
      for (uint64_t iEvent = 0; iEvent < numberOfEvents; ++iEvent) {
        test_data.loadEvent(iEvent);
        if (m_specific_options.m_normalize) {
          for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
            X[iEvent * numberOfFeatures + iFeature] = (test_data.m_input[iFeature] - m_means[iFeature]) / m_stds[iFeature];
        } else {
          for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
            X[iEvent * numberOfFeatures + iFeature] = test_data.m_input[iFeature];
        }
      }
 
      unsigned int nClasses = m_general_options.m_nClasses;
      std::vector<std::vector<float>> probabilities(test_data.getNumberOfEvents(), std::vector<float>(nClasses,
                                                    std::numeric_limits<float>::quiet_NaN()));
 
      try {
        auto ndarray_X = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_X, NPY_FLOAT32, X.get()));
        auto result = m_unique_mva_module.attr("apply")(m_state, ndarray_X);
        for (uint64_t iEvent = 0; iEvent < numberOfEvents; ++iEvent) {
          // We have to do some nasty casting here, because the Python C-Api uses structs which are binary compatible
          // to a PyObject but do not inherit from it!
          for (uint64_t iClass = 0; iClass < nClasses; ++iClass) {
            probabilities[iEvent][iClass] = static_cast<float>(*static_cast<float*>(PyArray_GETPTR2(reinterpret_cast<PyArrayObject*>
                                                               (result.ptr()),
                                                               iEvent, iClass)));
          }
        }
      } catch (...) {
        PyErr_Print();
        PyErr_Clear();
        B2ERROR("Failed calling applying PythonExpert");
        throw std::runtime_error("Failed calling applying PythonExpert");
      }
 
      return probabilities;
    }

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 408 of file Python.cc.

    {
 
      std::string custom_weightfile = weightfile.generateFileName();
      weightfile.getFile("Python_Weightfile", custom_weightfile);
      weightfile.getOptions(m_general_options);
      weightfile.getOptions(m_specific_options);
 
      if (m_specific_options.m_normalize) {
        m_means = weightfile.getVector<float>("Python_Means");
        m_stds = weightfile.getVector<float>("Python_Stds");
      }
 
      try {
        auto pickle = boost::python::import("pickle");
        auto builtins = boost::python::import("builtins");
 
        // Create a new empty module with a unique name.
        // This way we dont end up with multiple mvas trying to implement
        // the same apply method with the last one being used by all.
        boost::uuids::random_generator uuid_gen;
        std::string unique_mva_module_name = "custom_framework_" + boost::uuids::to_string(uuid_gen());
        boost::python::object type = boost::python::import("types");
        m_unique_mva_module = type.attr("ModuleType")(unique_mva_module_name.c_str());
 
        // Find the framework file. Then execute it in the scope of the new module
        auto framework = boost::python::import((std::string("basf2_mva_python_interface.") + m_specific_options.m_framework).c_str());
        auto framework_file = framework.attr("__file__");
        boost::python::extract<std::string> extractor(framework_file);
        std::string framework_filename = extractor();
        auto framework_file_source_code = loadPythonFileAsString(framework_filename);
        builtins.attr("exec")(framework_file_source_code.c_str(), boost::python::object(m_unique_mva_module.attr("__dict__")));
 
        // Overwrite framework with user-defined code from the steering file if defined
        if (weightfile.containsElement("Python_Steeringfile")) {
          std::string custom_steeringfile = weightfile.generateFileName();
          weightfile.getFile("Python_Steeringfile", custom_steeringfile);
          auto steeringfile = builtins.attr("open")(custom_steeringfile.c_str(), "rb");
          auto source_code = pickle.attr("load")(steeringfile);
          builtins.attr("exec")(boost::python::object(source_code), boost::python::object(m_unique_mva_module.attr("__dict__")));
        }
 
        auto file = builtins.attr("open")(custom_weightfile.c_str(), "rb");
        auto unpickled_fit_object = pickle.attr("load")(file);
        m_state = m_unique_mva_module.attr("load")(unpickled_fit_object);
      } catch (...) {
        PyErr_Print();
        PyErr_Clear();
        B2ERROR("Failed calling load in PythonExpert");
        throw std::runtime_error("Failed calling load in PythonExpert");
      }
 
    }

Member Data Documentation

m_general_options

GeneralOptions m_general_options

protectedinherited

General options loaded from the weightfile.

Definition at line 70 of file Expert.h.

m_means

std::vector<float> m_means

protected

Means of all features for normalization.

Definition at line 141 of file Python.h.

m_specific_options

PythonOptions m_specific_options

protected

Method specific options.

Definition at line 138 of file Python.h.

m_state

boost::python::object m_state

protected

current state object of method

Definition at line 140 of file Python.h.

m_stds

std::vector<float> m_stds

protected

Stds of all features for normalization.

Definition at line 142 of file Python.h.

m_unique_mva_module

boost::python::object m_unique_mva_module

protected

python module containing the mva methods

Definition at line 139 of file Python.h.

---

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

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