Belle II Software  release-05-01-25
Python.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2016 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Thomas Keck *
7  * Jochen Gemmler *
8  * *
9  * This software is provided "as is" without any warranty. *
10  **************************************************************************/
11 
12 #include <mva/methods/Python.h>
13 
14 #include <boost/filesystem/convenience.hpp>
15 #include <numpy/npy_common.h>
16 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
17 #include <numpy/arrayobject.h>
18 
19 #include <framework/logging/Logger.h>
20 #include <framework/utilities/FileSystem.h>
21 #include <fstream>
22 
23 namespace Belle2 {
28  namespace MVA {
29 
30  void PythonOptions::load(const boost::property_tree::ptree& pt)
31  {
32  int version = pt.get<int>("Python_version");
33  if (version < 1 or version > 2) {
34  B2ERROR("Unknown weightfile version " << std::to_string(version));
35  throw std::runtime_error("Unknown weightfile version " + std::to_string(version));
36  }
37  m_framework = pt.get<std::string>("Python_framework");
38  m_steering_file = pt.get<std::string>("Python_steering_file");
39  m_mini_batch_size = pt.get<unsigned int>("Python_mini_batch_size");
40  m_nIterations = pt.get<unsigned int>("Python_n_iterations");
41  m_config = pt.get<std::string>("Python_config");
42  m_training_fraction = pt.get<double>("Python_training_fraction");
43  if (version == 2) {
44  m_normalize = pt.get<bool>("Python_normalize");
45  } else {
46  m_normalize = false;
47  }
48 
49  }
50 
51  void PythonOptions::save(boost::property_tree::ptree& pt) const
52  {
53  pt.put("Python_version", 2);
54  pt.put("Python_framework", m_framework);
55  pt.put("Python_steering_file", m_steering_file);
56  pt.put("Python_mini_batch_size", m_mini_batch_size);
57  pt.put("Python_n_iterations", m_nIterations);
58  pt.put("Python_config", m_config);
59  pt.put("Python_training_fraction", m_training_fraction);
60  pt.put("Python_normalize", m_normalize);
61  }
62 
63  po::options_description PythonOptions::getDescription()
64  {
65  po::options_description description("Python options");
66  description.add_options()
67  ("framework", po::value<std::string>(&m_framework),
68  "Framework which should be used. Currently supported are sklearn, tensorflow and theano")
69  ("steering_file", po::value<std::string>(&m_steering_file), "Steering file which describes")
70  ("mini_batch_size", po::value<unsigned int>(&m_mini_batch_size), "Size of the mini batch given to partial_fit function")
71  ("nIterations", po::value<unsigned int>(&m_nIterations), "Number of iterations")
72  ("normalize", po::value<bool>(&m_normalize), "Normalize input data (shift mean to 0 and std to 1)")
73  ("training_fraction", po::value<double>(&m_training_fraction),
74  "Training fraction used to split up dataset in training and validation sample.")
75  ("config", po::value<std::string>(&m_config), "Json encoded python object passed to begin_fit function");
76  return description;
77  }
78 
84 
85  public:
90 
95 
96  private:
101  {
102  if (not Py_IsInitialized()) {
103  Py_Initialize();
104  // wchar_t* bla[] = {L""};
105  wchar_t** bla = nullptr;
106  PySys_SetArgvEx(0, bla, 0);
107  m_initialized_python = true;
108  }
109 
110  if (PyArray_API == nullptr) {
111  init_numpy();
112  }
113  }
114 
119  {
120  if (m_initialized_python) {
121  if (Py_IsInitialized()) {
122  // We don't finalize Python because this call only frees some memory,
123  // but can cause crashes in loaded python-modules like Theano
124  // https://docs.python.org/3/c-api/init.html
125  // Py_Finalize();
126  }
127  }
128  }
129 
135  void* init_numpy()
136  {
137  // Import array is a macro which returns NUMPY_IMPORT_ARRAY_RETVAL
138  import_array();
139  return nullptr;
140  }
141 
142  bool m_initialized_python = false;
143  };
144 
146  {
147  static PythonInitializerSingleton singleton;
148  return singleton;
149  }
150 
151 
153  const PythonOptions& specific_options) : Teacher(general_options),
154  m_specific_options(specific_options)
155  {
157  }
158 
159 
161  {
162 
163  Weightfile weightfile;
164  std::string custom_weightfile = weightfile.generateFileName();
165  std::string custom_steeringfile = weightfile.generateFileName();
166 
167  uint64_t numberOfFeatures = training_data.getNumberOfFeatures();
168  uint64_t numberOfSpectators = training_data.getNumberOfSpectators();
169  uint64_t numberOfEvents = training_data.getNumberOfEvents();
170 
171  auto numberOfValidationEvents = static_cast<uint64_t>(numberOfEvents * (1 - m_specific_options.m_training_fraction));
172  auto numberOfTrainingEvents = static_cast<uint64_t>(numberOfEvents * m_specific_options.m_training_fraction);
173 
174  uint64_t batch_size = m_specific_options.m_mini_batch_size;
175  if (batch_size == 0) {
176  batch_size = numberOfTrainingEvents;
177  }
178 
180  B2ERROR("Please provide a positive training fraction");
181  throw std::runtime_error("Please provide a training fraction between (0.0,1.0]");
182  }
183 
184  auto X = std::unique_ptr<float[]>(new float[batch_size * numberOfFeatures]);
185  auto S = std::unique_ptr<float[]>(new float[batch_size * numberOfSpectators]);
186  auto y = std::unique_ptr<float[]>(new float[batch_size]);
187  auto w = std::unique_ptr<float[]>(new float[batch_size]);
188  npy_intp dimensions_X[2] = {static_cast<npy_intp>(batch_size), static_cast<npy_intp>(numberOfFeatures)};
189  npy_intp dimensions_S[2] = {static_cast<npy_intp>(batch_size), static_cast<npy_intp>(numberOfSpectators)};
190  npy_intp dimensions_y[2] = {static_cast<npy_intp>(batch_size), 1};
191  npy_intp dimensions_w[2] = {static_cast<npy_intp>(batch_size), 1};
192 
193  auto X_v = std::unique_ptr<float[]>(new float[numberOfValidationEvents * numberOfFeatures]);
194  auto S_v = std::unique_ptr<float[]>(new float[numberOfValidationEvents * numberOfSpectators]);
195  auto y_v = std::unique_ptr<float[]>(new float[numberOfValidationEvents]);
196  auto w_v = std::unique_ptr<float[]>(new float[numberOfValidationEvents]);
197  npy_intp dimensions_X_v[2] = {static_cast<npy_intp>(numberOfValidationEvents), static_cast<npy_intp>(numberOfFeatures)};
198  npy_intp dimensions_S_v[2] = {static_cast<npy_intp>(numberOfValidationEvents), static_cast<npy_intp>(numberOfSpectators)};
199  npy_intp dimensions_y_v[2] = {static_cast<npy_intp>(numberOfValidationEvents), 1};
200  npy_intp dimensions_w_v[2] = {static_cast<npy_intp>(numberOfValidationEvents), 1};
201 
202  std::string steering_file_source_code;
205  std::ifstream steering_file(filename);
206  if (not steering_file) {
207  throw std::runtime_error(std::string("Couldn't open file ") + filename);
208  }
209  steering_file.seekg(0, std::ios::end);
210  steering_file_source_code.resize(steering_file.tellg());
211  steering_file.seekg(0, std::ios::beg);
212  steering_file.read(&steering_file_source_code[0], steering_file_source_code.size());
213  }
214 
215  std::vector<float> means(numberOfFeatures, 0.0);
216  std::vector<float> stds(numberOfFeatures, 0.0);
217 
219  // Stable calculation of mean and variance with weights
220  // see https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
221  auto weights = training_data.getWeights();
222  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature) {
223  double wSum = 0.0;
224  double wSum2 = 0.0;
225  double mean = 0.0;
226  double running_std = 0.0;
227  auto feature = training_data.getFeature(iFeature);
228  for (uint64_t i = 0; i < weights.size(); ++i) {
229  wSum += weights[i];
230  wSum2 += weights[i] * weights[i];
231  double meanOld = mean;
232  mean += (weights[i] / wSum) * (feature[i] - meanOld);
233  running_std += weights[i] * (feature[i] - meanOld) * (feature[i] - mean);
234  }
235  means[iFeature] = mean;
236  stds[iFeature] = std::sqrt(running_std / (wSum - 1));
237  }
238  }
239 
240  try {
241  // Load python modules
242  auto json = boost::python::import("json");
243  auto builtins = boost::python::import("builtins");
244  auto inspect = boost::python::import("inspect");
245 
246  // Load framework
247  auto framework = boost::python::import((std::string("basf2_mva_python_interface.") + m_specific_options.m_framework).c_str());
248  // Overwrite framework with user-defined code from the steering file
249  builtins.attr("exec")(steering_file_source_code.c_str(), boost::python::object(framework.attr("__dict__")));
250 
251  // Call get_model with the parameters provided by the user
252  auto parameters = json.attr("loads")(m_specific_options.m_config.c_str());
253  auto model = framework.attr("get_model")(numberOfFeatures, numberOfSpectators,
254  numberOfEvents, m_specific_options.m_training_fraction, parameters);
255 
256  // Call begin_fit with validation sample
257  for (uint64_t iEvent = 0; iEvent < numberOfValidationEvents; ++iEvent) {
258  training_data.loadEvent(iEvent);
260  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
261  X_v[iEvent * numberOfFeatures + iFeature] = (training_data.m_input[iFeature] - means[iFeature]) / stds[iFeature];
262  } else {
263  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
264  X_v[iEvent * numberOfFeatures + iFeature] = training_data.m_input[iFeature];
265  }
266  for (uint64_t iSpectator = 0; iSpectator < numberOfSpectators; ++iSpectator)
267  S_v[iEvent * numberOfSpectators + iSpectator] = training_data.m_spectators[iSpectator];
268  y_v[iEvent] = training_data.m_target;
269  w_v[iEvent] = training_data.m_weight;
270  }
271 
272  auto ndarray_X_v = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_X_v, NPY_FLOAT32, X_v.get()));
273  auto ndarray_S_v = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_S_v, NPY_FLOAT32, S_v.get()));
274  auto ndarray_y_v = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_y_v, NPY_FLOAT32, y_v.get()));
275  auto ndarray_w_v = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_w_v, NPY_FLOAT32, w_v.get()));
276 
277  auto state = framework.attr("begin_fit")(model, ndarray_X_v, ndarray_S_v, ndarray_y_v, ndarray_w_v);
278 
279  uint64_t nBatches = std::floor(numberOfTrainingEvents / batch_size);
280  bool continue_loop = true;
281  for (uint64_t iIteration = 0; (iIteration < m_specific_options.m_nIterations or m_specific_options.m_nIterations == 0)
282  and continue_loop; ++iIteration) {
283  for (uint64_t iBatch = 0; iBatch < nBatches and continue_loop; ++iBatch) {
284 
285  // Release Global Interpreter Lock in python to allow multithreading while reading root files
286  // also see: https://docs.python.org/3.5/c-api/init.html
287  PyThreadState* m_thread_state = PyEval_SaveThread();
288  for (uint64_t iEvent = 0; iEvent < batch_size; ++iEvent) {
289  training_data.loadEvent(iEvent + iBatch * batch_size + numberOfValidationEvents);
291  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
292  X[iEvent * numberOfFeatures + iFeature] = (training_data.m_input[iFeature] - means[iFeature]) / stds[iFeature];
293  } else {
294  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
295  X[iEvent * numberOfFeatures + iFeature] = training_data.m_input[iFeature];
296  }
297  for (uint64_t iSpectator = 0; iSpectator < numberOfSpectators; ++iSpectator)
298  S[iEvent * numberOfSpectators + iSpectator] = training_data.m_spectators[iSpectator];
299  y[iEvent] = training_data.m_target;
300  w[iEvent] = training_data.m_weight;
301  }
302 
303  // Maybe slow, create ndarrays outside of loop?
304  auto ndarray_X = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_X, NPY_FLOAT32, X.get()));
305  auto ndarray_S = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_S, NPY_FLOAT32, S.get()));
306  auto ndarray_y = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_y, NPY_FLOAT32, y.get()));
307  auto ndarray_w = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_w, NPY_FLOAT32, w.get()));
308 
309  // Reactivate Global Interpreter Lock to safely execute python code
310  PyEval_RestoreThread(m_thread_state);
311  auto r = framework.attr("partial_fit")(state, ndarray_X, ndarray_S, ndarray_y,
312  ndarray_w, iIteration * nBatches + iBatch);
313  boost::python::extract<bool> proxy(r);
314  if (proxy.check())
315  continue_loop = static_cast<bool>(proxy);
316  }
317  }
318 
319  auto result = framework.attr("end_fit")(state);
320 
321  auto pickle = boost::python::import("pickle");
322  auto file = builtins.attr("open")(custom_weightfile.c_str(), "wb");
323  pickle.attr("dump")(result, file);
324 
325  auto steeringfile = builtins.attr("open")(custom_steeringfile.c_str(), "wb");
326  pickle.attr("dump")(steering_file_source_code.c_str(), steeringfile);
327 
328  auto importances = framework.attr("feature_importance")(state);
329  if (len(importances) == 0) {
330  B2INFO("Python method returned empty feature importance. There won't be any information about the feature importance in the weightfile.");
331  } else if (numberOfFeatures != static_cast<uint64_t>(len(importances))) {
332  B2WARNING("Python method didn't return the correct number of importance value. I ignore the importances");
333  } else {
334  std::map<std::string, float> feature_importances;
335  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature) {
336  boost::python::extract<float> proxy(importances[iFeature]);
337  if (proxy.check()) {
338  feature_importances[m_general_options.m_variables[iFeature]] = static_cast<float>(proxy);
339  } else {
340  B2WARNING("Failed to convert importance output of the method to a float, using 0 instead");
341  feature_importances[m_general_options.m_variables[iFeature]] = 0.0;
342  }
343  }
344  weightfile.addFeatureImportance(feature_importances);
345  }
346 
347  } catch (...) {
348  PyErr_Print();
349  PyErr_Clear();
350  B2ERROR("Failed calling train in PythonTeacher");
351  throw std::runtime_error(std::string("Failed calling train in PythonTeacher"));
352  }
353 
354  weightfile.addOptions(m_general_options);
355  weightfile.addOptions(m_specific_options);
356  weightfile.addFile("Python_Weightfile", custom_weightfile);
357  weightfile.addFile("Python_Steeringfile", custom_steeringfile);
358  weightfile.addSignalFraction(training_data.getSignalFraction());
360  weightfile.addVector("Python_Means", means);
361  weightfile.addVector("Python_Stds", stds);
362  }
363 
364  return weightfile;
365 
366  }
367 
369  {
371  }
372 
373 
374  void PythonExpert::load(Weightfile& weightfile)
375  {
376 
377  std::string custom_weightfile = weightfile.generateFileName();
378  weightfile.getFile("Python_Weightfile", custom_weightfile);
379  weightfile.getOptions(m_general_options);
380  weightfile.getOptions(m_specific_options);
381 
383  m_means = weightfile.getVector<float>("Python_Means");
384  m_stds = weightfile.getVector<float>("Python_Stds");
385  }
386 
387  try {
388  auto pickle = boost::python::import("pickle");
389  auto builtins = boost::python::import("builtins");
390  m_framework = boost::python::import((std::string("basf2_mva_python_interface.") + m_specific_options.m_framework).c_str());
391 
392  if (weightfile.containsElement("Python_Steeringfile")) {
393  std::string custom_steeringfile = weightfile.generateFileName();
394  weightfile.getFile("Python_Steeringfile", custom_steeringfile);
395  auto steeringfile = builtins.attr("open")(custom_steeringfile.c_str(), "rb");
396  auto source_code = pickle.attr("load")(steeringfile);
397  builtins.attr("exec")(boost::python::object(source_code), boost::python::object(m_framework.attr("__dict__")));
398  }
399 
400  auto file = builtins.attr("open")(custom_weightfile.c_str(), "rb");
401  auto unpickled_fit_object = pickle.attr("load")(file);
402  m_state = m_framework.attr("load")(unpickled_fit_object);
403  } catch (...) {
404  PyErr_Print();
405  PyErr_Clear();
406  B2ERROR("Failed calling load in PythonExpert");
407  throw std::runtime_error("Failed calling load in PythonExpert");
408  }
409 
410  }
411 
412  std::vector<float> PythonExpert::apply(Dataset& test_data) const
413  {
414 
415  uint64_t numberOfFeatures = test_data.getNumberOfFeatures();
416  uint64_t numberOfEvents = test_data.getNumberOfEvents();
417 
418  auto X = std::unique_ptr<float[]>(new float[numberOfEvents * numberOfFeatures]);
419  npy_intp dimensions_X[2] = {static_cast<npy_intp>(numberOfEvents), static_cast<npy_intp>(numberOfFeatures)};
420 
421  for (uint64_t iEvent = 0; iEvent < numberOfEvents; ++iEvent) {
422  test_data.loadEvent(iEvent);
424  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
425  X[iEvent * numberOfFeatures + iFeature] = (test_data.m_input[iFeature] - m_means[iFeature]) / m_stds[iFeature];
426  } else {
427  for (uint64_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
428  X[iEvent * numberOfFeatures + iFeature] = test_data.m_input[iFeature];
429  }
430  }
431 
432  std::vector<float> probabilities(test_data.getNumberOfEvents());
433 
434  try {
435  auto ndarray_X = boost::python::handle<>(PyArray_SimpleNewFromData(2, dimensions_X, NPY_FLOAT32, X.get()));
436  auto result = m_framework.attr("apply")(m_state, ndarray_X);
437  for (uint64_t iEvent = 0; iEvent < numberOfEvents; ++iEvent) {
438  // We have to do some nasty casting here, because the Python C-Api uses structs which are binary compatible
439  // to a PyObject but do not inherit from it!
440  probabilities[iEvent] = static_cast<float>(*static_cast<float*>(PyArray_GETPTR1(reinterpret_cast<PyArrayObject*>(result.ptr()),
441  iEvent)));
442  }
443  } catch (...) {
444  PyErr_Print();
445  PyErr_Clear();
446  B2ERROR("Failed calling applying PythonExpert");
447  throw std::runtime_error("Failed calling applying PythonExpert");
448  }
449 
450  return probabilities;
451  }
452  }
454 }
Belle2::MVA::PythonInitializerSingleton::init_numpy
void * init_numpy()
Helper funtion which initializes array system of numpy.
Definition: Python.cc:135
Belle2::MVA::PythonTeacher::m_specific_options
PythonOptions m_specific_options
Method specific options.
Definition: Python.h:109
Belle2::MVA::PythonOptions::save
virtual void save(boost::property_tree::ptree &pt) const override
Save mechanism to store Options in a xml tree.
Definition: Python.cc:51
Belle2::MVA::PythonInitializerSingleton
Singleton class which handles the initialization and finalization of Python and numpy.
Definition: Python.cc:83
Belle2::MVA::Weightfile::getVector
std::vector< T > getVector(const std::string &identifier) const
Returns a stored vector from the xml tree.
Definition: Weightfile.h:182
Belle2::MVA::Dataset
Abstract base class of all Datasets given to the MVA interface The current event can always be access...
Definition: Dataset.h:34
Belle2::MVA::PythonExpert::load
virtual void load(Weightfile &weightfile) override
Load the expert from a Weightfile.
Definition: Python.cc:374
Belle2::MVA::Weightfile::addSignalFraction
void addSignalFraction(float signal_fraction)
Saves the signal fraction in the xml tree.
Definition: Weightfile.cc:104
Belle2::MVA::Weightfile::getOptions
void getOptions(Options &options) const
Fills an Option object from the xml tree.
Definition: Weightfile.cc:76
Belle2::MVA::Weightfile::containsElement
bool containsElement(const std::string &identifier) const
Returns true if given element is stored in the property tree.
Definition: Weightfile.h:162
Belle2::MVA::PythonOptions::load
virtual void load(const boost::property_tree::ptree &pt) override
Load mechanism to load Options from a xml tree.
Definition: Python.cc:30
Belle2::MVA::Weightfile::addFile
void addFile(const std::string &identifier, const std::string &custom_weightfile)
Add a file (mostly a weightfile from a MVA library) to our Weightfile.
Definition: Weightfile.cc:124
Belle2::MVA::Weightfile
The Weightfile class serializes all information about a training into an xml tree.
Definition: Weightfile.h:40
Belle2::MVA::PythonInitializerSingleton::~PythonInitializerSingleton
~PythonInitializerSingleton()
Destructor of PythonInitializerSingleton.
Definition: Python.cc:118
Belle2::MVA::PythonTeacher::train
virtual Weightfile train(Dataset &training_data) const override
Train a mva method using the given dataset returning a Weightfile.
Definition: Python.cc:160
Belle2::MVA::PythonOptions::m_normalize
bool m_normalize
Normalize the inputs (shift mean to zero and std to 1)
Definition: Python.h:85
Belle2::MVA::Weightfile::addFeatureImportance
void addFeatureImportance(const std::map< std::string, float > &importance)
Add variable importance.
Definition: Weightfile.cc:81
Belle2::MVA::Weightfile::addVector
void addVector(const std::string &identifier, const std::vector< T > &vector)
Add a vector to the xml tree.
Definition: Weightfile.h:127
Belle2::MVA::PythonExpert::m_framework
boost::python::object m_framework
Framework module.
Definition: Python.h:137
Belle2::MVA::Teacher::m_general_options
GeneralOptions m_general_options
GeneralOptions containing all shared options.
Definition: Teacher.h:51
Belle2::MVA::PythonOptions::m_nIterations
unsigned int m_nIterations
Number of iterations trough the whole data.
Definition: Python.h:83
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::MVA::Teacher
Abstract base class of all Teachers Each MVA library has its own implementation of this class,...
Definition: Teacher.h:31
Belle2::MVA::Weightfile::addOptions
void addOptions(const Options &options)
Add an Option object to the xml tree.
Definition: Weightfile.cc:71
Belle2::MVA::PythonExpert::m_state
boost::python::object m_state
current state object of method
Definition: Python.h:138
Belle2::MVA::PythonExpert::m_stds
std::vector< float > m_stds
Stds of all features for normalization.
Definition: Python.h:140
Belle2::MVA::PythonOptions::m_steering_file
std::string m_steering_file
steering file provided by the user to override the functions in the framework
Definition: Python.h:80
Belle2::MVA::GeneralOptions::m_variables
std::vector< std::string > m_variables
Vector of all variables (branch names) used in the training.
Definition: Options.h:88
Belle2::MVA::GeneralOptions
General options which are shared by all MVA trainings.
Definition: Options.h:64
Belle2::MVA::Weightfile::getFile
void getFile(const std::string &identifier, const std::string &custom_weightfile)
Creates a file from our weightfile (mostly this will be a weightfile of an MVA library)
Definition: Weightfile.cc:147
Belle2::MVA::PythonInitializerSingleton::PythonInitializerSingleton
PythonInitializerSingleton()
Constructor of PythonInitializerSingleton.
Definition: Python.cc:100
Belle2::MVA::PythonOptions::m_training_fraction
double m_training_fraction
Fraction of data passed as training data, rest is passed as test data.
Definition: Python.h:84
Belle2::MVA::PythonOptions::m_mini_batch_size
unsigned int m_mini_batch_size
Mini batch size, 0 passes the whole data in one call.
Definition: Python.h:82
Belle2::MVA::Weightfile::generateFileName
std::string generateFileName(const std::string &suffix="")
Returns a temporary filename with the given suffix.
Definition: Weightfile.cc:114
Belle2::MVA::PythonOptions::getDescription
virtual po::options_description getDescription() override
Returns a program options description for all available options.
Definition: Python.cc:63
Belle2::MVA::PythonExpert::apply
virtual std::vector< float > apply(Dataset &test_data) const override
Apply this expert onto a dataset.
Definition: Python.cc:412
Belle2::MVA::Expert::m_general_options
GeneralOptions m_general_options
General options loaded from the weightfile.
Definition: Expert.h:74
Belle2::FileSystem::findFile
static std::string findFile(const std::string &path, bool silent=false)
Search for given file or directory in local or central release directory, and return absolute path if...
Definition: FileSystem.cc:147
Belle2::MVA::PythonExpert::m_specific_options
PythonOptions m_specific_options
Method specific options.
Definition: Python.h:136
Belle2::MVA::PythonExpert::PythonExpert
PythonExpert()
Constructs a new Python Expert.
Definition: Python.cc:368
Belle2::MVA::PythonOptions::m_framework
std::string m_framework
framework to use e.g.
Definition: Python.h:79
Belle2::MVA::PythonInitializerSingleton::GetInstance
static PythonInitializerSingleton & GetInstance()
Return static instance of PythonInitializerSingleton.
Definition: Python.cc:145
Belle2::MVA::PythonOptions
Options for the Python MVA method.
Definition: Python.h:54
Belle2::MVA::PythonExpert::m_means
std::vector< float > m_means
Means of all features for normalization.
Definition: Python.h:139
Belle2::MVA::PythonTeacher::PythonTeacher
PythonTeacher(const GeneralOptions &general_options, const PythonOptions &specific_options)
Constructs a new teacher using the GeneralOptions and specific options of this training.
Definition: Python.cc:152
Belle2::MVA::PythonInitializerSingleton::m_initialized_python
bool m_initialized_python
Member which keeps indicate if this class initialized python.
Definition: Python.cc:142
Belle2::MVA::PythonOptions::m_config
std::string m_config
Config string in json, which is passed to the get model function.
Definition: Python.h:81