PythonExpert Class Reference

Expert for the Python MVA method. More...

#include <Python.h>

Inheritance diagram for PythonExpert:

Collaboration diagram for PythonExpert:

Public Member Functions
	PythonExpert ()
	Constructs a new Python Expert.
virtual void	load (Weightfile &weightfile) override
	Load the expert from a Weightfile. More...
virtual std::vector< float >	apply (Dataset &test_data) const override
	Apply this expert onto a dataset. More...
virtual std::vector< float >	apply (Dataset &test_data, const unsigned int classID) const
	Apply this expert onto a dataset. More...

Protected Attributes
PythonOptions	m_specific_options
	Method specific options.
boost::python::object	m_framework
	Framework module.
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 115 of file Python.h.

Member Function Documentation

apply() [1/2]

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

overridevirtual

Apply this expert onto a dataset.

Parameters

test_data

dataset

Implements Expert.

Definition at line 412 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());
 
      try {
        auto ndarray_X = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_X, NPY_FLOAT32, X.get()));
        auto result = m_framework.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;
    }

apply() [2/2]

virtual std::vector<float> apply ( Dataset &  test_data, const unsigned int  classID  ) const

inlinevirtualinherited

Apply this expert onto a dataset.

Multi-class mode signature. Not pure virtual, since not all derived classes need to re-implement this.

Parameters

test_data	dataset
classID	class identifier.

Reimplemented in TMVAExpertMulticlass.

Definition at line 59 of file Expert.h.

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

---

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

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