pybdt C++ API Reference

class BDTLearner : public Learner
#include <bdtlearner.hpp>

Public Functions

explicit BDTLearner(const std::vector<std::string> &feature_names, const std::string &weight_name = "")
BDTLearner(const std::vector<std::string> &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)
explicit BDTLearner(const boost::python::list &feature_names, const std::string &weight_name = "")
BDTLearner(const boost::python::list &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)
virtual ~BDTLearner()
double beta() const
double frac_random_events() const
int num_trees() const
bool use_purity() const
bool quiet() const
boost::python::list after_pruners() const
boost::python::list before_pruners() const
void beta(double beta)
void frac_random_events(double n)
void num_trees(int n)
void use_purity(bool purity)
void quiet(bool val)
void add_after_pruner(boost::shared_ptr<Pruner> pruner)
void add_before_pruner(boost::shared_ptr<Pruner> pruner)
void clear_after_pruners()
void clear_before_pruners()
void set_defaults()
boost::shared_ptr<DTLearner> dtlearner()
virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &init_sig_weights, const std::vector<double> &init_bg_weights) const

Protected Attributes

boost::shared_ptr<DTLearner> m_dtlearner
double m_beta
double m_frac_random_events
int m_num_trees
bool m_use_purity
bool m_quiet
std::vector<boost::shared_ptr<Pruner>> m_before_pruners
std::vector<boost::shared_ptr<Pruner>> m_after_pruners

Friends

friend class BDTLearner_pickle_suite
class BDTModel : public Model
#include <bdtmodel.hpp>

Public Functions

BDTModel(const std::vector<std::string> &feature_names, const std::vector<boost::shared_ptr<DTModel>> &dtmodels, const std::vector<double> &alphas)
virtual ~BDTModel()
BDTModel(const boost::python::list &feature_names, const boost::python::list &dtmodels, const boost::python::list &alphas)
double get_alpha(int n) const
boost::shared_ptr<DTModel> get_dtmodel(int n) const
int n_dtmodels() const
std::vector<double> event_variable_importance(const Scoreable &s, bool sep_weighted, bool tree_weighted) const
boost::python::dict event_variable_importance_py(const boost::python::list &vals, bool sep_weighted, bool tree_weighted) const
std::vector<double> variable_importance(bool sep_weighted, bool tree_weighted) const
boost::python::dict variable_importance_py(bool sep_weighted, bool tree_weighted) const
boost::shared_ptr<BDTModel> get_subset_bdtmodel(int n_i, int n_f) const
boost::shared_ptr<BDTModel> get_subset_bdtmodel_list(boost::python::list dtmodel_indices) const
boost::shared_ptr<BDTModel> get_trimmed_bdtmodel(double threshold) const

Protected Functions

virtual double base_score(const Scoreable &e, bool use_purity) const

Private Members

std::vector<boost::shared_ptr<DTModel>> m_dtmodels
std::vector<double> m_alphas
int m_n_dtmodels
double m_max_response

Friends

friend struct BDTModel_pickle_suite
struct BDTModel_pickle_suite : public pickle_suite
#include <bdtmodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const BDTModel &m)
class CostComplexityPruner : public Pruner
#include <pruner.hpp>

Public Functions

explicit CostComplexityPruner(double strength)
virtual ~CostComplexityPruner()
virtual void prune(boost::shared_ptr<DTModel> tree)
double strength() const
void strength(double s)

Public Static Functions

static double gain(const boost::shared_ptr<DTNode> node)
static double rho(const boost::shared_ptr<DTNode> node)

Private Members

double m_strength
class DataSet
#include <dataset.hpp>

Public Functions

explicit DataSet(const boost::python::dict &data, const std::string subset = "all")
DataSet(const DataSet &other, const std::vector<std::string> &names)
inline const Event &event(int index) const
inline const std::vector<Event> &events() const
std::vector<double> get_column(const std::string &name) const
int get_column_index(const std::string &name) const
std::vector<int> get_column_indices(const std::vector<std::string> &feature_names) const
PyObject *getitem(const std::string &name) const
inline double livetime() const
std::vector<std::string> names() const
boost::python::list names_py() const
inline int n_features() const
inline int n_events() const
boost::python::dict to_dict() const
inline void livetime(const double t)

Protected Attributes

std::vector<std::string> m_names
std::vector<Event> m_events
int m_n_features
int m_n_events
double m_livetime
std::vector<std::vector<double>> m_cols

Friends

friend class Event
class DTLearner : public Learner
#include <dtlearner.hpp>

Public Functions

explicit DTLearner(const std::vector<std::string> &feature_names, const std::string &weight_name = "")
DTLearner(const std::vector<std::string> &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)
virtual ~DTLearner()
explicit DTLearner(const boost::python::list &feature_names, const std::string &weight_name = "")
DTLearner(const boost::python::list &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)
bool linear_cuts() const
int max_depth() const
int min_split() const
int num_cuts() const
int num_random_variables() const
std::string separation_type() const
void max_depth(int n)
void min_split(int n)
void num_cuts(int n)
void linear_cuts(bool value)
void num_random_variables(int n)
void separation_type(std::string st)
void set_defaults()
virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &sig_weights, const std::vector<double> &bg_weights) const

Protected Functions

boost::shared_ptr<DTNode> build_tree(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &sig_weights, const std::vector<double> &bg_weights, const int depth = 0) const

Protected Attributes

boost::shared_ptr<SepFunc> m_sep_func
int m_min_split
int m_max_depth
int m_num_cuts
bool m_linear_cuts
int m_num_random_variables
mutable RandomSampler m_random_sampler

Protected Static Functions

static boost::tuple<double, double> m_sum_passing_weight(const double cut_val, const std::vector<double> &feature_col, const std::vector<double> &weights, const std::vector<int> &idx)

Friends

friend class BDTLearner
friend class BDTLearner_pickle_suite
class DTModel : public Model
#include <dtmodel.hpp>

Public Functions

DTModel(const std::vector<std::string> &feature_names, boost::shared_ptr<DTNode> root)
virtual ~DTModel()
DTModel(const boost::python::list &feature_names, boost::shared_ptr<DTNode> root)
std::vector<double> event_variable_importance(const Scoreable &s, bool sep_weighted) const
boost::python::dict event_variable_importance_py(const boost::python::list &vals, bool sep_weighted) const
std::vector<double> variable_importance(bool sep_weighted) const
boost::python::dict variable_importance_py(bool sep_weighted) const
inline boost::shared_ptr<DTNode> root()

Protected Functions

virtual double base_score(const Scoreable &e, bool use_purity) const

Protected Attributes

boost::shared_ptr<DTNode> m_root

Friends

friend struct DTModel_pickle_suite
struct DTModel_pickle_suite : public pickle_suite
#include <dtmodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const DTModel &m)
class DTNode : public boost::enable_shared_from_this<DTNode>
#include <dtmodel.hpp>

Public Functions

DTNode(double sep_index, double w_sig, double w_bg, int n_sig, int n_bg)
DTNode(double sep_gain, double sep_index, int feature_id, double feature_val, double w_sig, double w_bg, int n_sig, int n_bg, boost::shared_ptr<DTNode> left, boost::shared_ptr<DTNode> right)
virtual ~DTNode()
void set_dtmodel(boost::shared_ptr<DTModel> model)
void set_dtmodel(DTModel *model)
inline int feature_id() const
std::string feature_name() const
inline double feature_val() const
inline bool is_leaf() const
int max_depth() const
inline double n_bg() const
int n_leaves() const
int n_total() const
inline double n_sig() const
inline double purity() const
inline double sep_index() const
inline double sep_gain() const
int tree_size() const
inline double w_bg() const
inline double w_sig() const
double w_total() const
inline boost::shared_ptr<DTNode> left() const
inline boost::shared_ptr<DTNode> right() const
void prune()
const DTNode &trace(const Scoreable &e)
std::vector<boost::shared_ptr<DTNode>> trace_full(const Scoreable &e)
boost::shared_ptr<DTNode> get_copy() const

Protected Functions

void calc_aux()

Protected Attributes

double m_sep_gain
double m_sep_index
int m_feature_id
double m_feature_val
double m_w_sig
double m_w_bg
int m_n_sig
int m_n_bg
double m_purity
boost::shared_ptr<DTNode> m_left
boost::shared_ptr<DTNode> m_right
DTModel *m_dtmodel

Friends

friend struct DTNode_pickle_suite
struct DTNode_pickle_suite : public pickle_suite
#include <dtmodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const DTNode &n)
class ErrorPruner : public Pruner
#include <pruner.hpp>

Public Functions

explicit ErrorPruner(double factor)
virtual ~ErrorPruner()
virtual void prune(boost::shared_ptr<DTModel> tree)
double node_error(const boost::shared_ptr<DTNode> node)
double subtree_error(const boost::shared_ptr<DTNode> node)
double strength() const
void strength(double s)

Private Functions

std::vector<boost::shared_ptr<DTNode>> get_prune_sequence(boost::shared_ptr<DTNode> node)

Private Members

double m_strength
class Event
#include <dataset.hpp>

Public Functions

Event(const DataSet *dataset, const int row)
Event &operator=(const Event &e)
inline double operator[](const size_type index) const
inline bool all_finite() const
inline int get_column_index(const std::string &name) const
inline size_type size() const
inline double value(const size_type index) const
inline std::vector<double> values() const

Private Types

typedef std::vector<double>::size_type size_type

Private Members

const DataSet *m_dataset
int m_row
class Histogram
#include <histogram.hpp>

Subclassed by LinearHistogram, NonlinearHistogram

Public Functions

virtual ~Histogram()
virtual double count(int i) const = 0
virtual std::vector<double>::const_iterator begin() const = 0
virtual std::vector<double>::const_iterator end() const = 0
virtual double min_val() const = 0
virtual double max_val() const = 0
virtual int n_bins() const = 0
void fill(const std::vector<double> &values)
virtual void fill(const std::vector<double> &values, const std::vector<double> &weights) = 0
virtual int index_for_value(double value) const = 0
virtual double value_for_index(int i) const = 0
class Learner
#include <learner.hpp>

Subclassed by BDTLearner, DTLearner, VineLearner

Public Functions

explicit Learner(const std::vector<std::string> &feature_names, const std::string &weight_name = "")
Learner(const std::vector<std::string> &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)
virtual ~Learner()
explicit Learner(const boost::python::list &feature_names, const std::string &weight_name = "")
Learner(const boost::python::list &feature_names, const std::string &sig_weight_name, const std::string &bg_weight_name)
std::vector<std::string> feature_names() const
std::string sig_weight_name() const
std::string bg_weight_name() const
boost::shared_ptr<Model> train(const DataSet &sig, const DataSet &bg) const
boost::shared_ptr<Model> train_given_weights(const DataSet &sig, const DataSet &bg, const std::vector<double> &sig_weights, const std::vector<double> &bg_weights) const
virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &init_sig_weights, const std::vector<double> &init_bg_weights) const = 0

Protected Attributes

std::vector<std::string> m_feature_names
std::string m_sig_weight_name
std::string m_bg_weight_name

Private Functions

void init()
class LinearHistogram : public Histogram

Public Functions

LinearHistogram(double min_val, double max_val, int n_bins)
~LinearHistogram()
virtual double count(int i) const
virtual std::vector<double>::const_iterator begin() const
virtual std::vector<double>::const_iterator end() const
virtual double min_val() const
virtual double max_val() const
virtual int n_bins() const
void fill(double value, double weight = 1.0)
void fill(const std::vector<double> &values)
virtual void fill(const std::vector<double> &values, const std::vector<double> &weights)
virtual int index_for_value(double value) const
virtual double value_for_index(int i) const

Private Members

double m_min_val
double m_max_val
int m_n_bins
double m_bin_width
double m_underflow
double m_overflow
std::vector<double> m_bin_values
class Model
#include <model.hpp>

Subclassed by BDTModel, DTModel, VineModel

Public Functions

Model(std::vector<std::string> feature_names)
Model(boost::python::list feature_names)
virtual ~Model()
std::vector<std::string> feature_names() const
boost::python::list feature_names_py() const
double score(const Scoreable &s, bool use_purity = false)
std::vector<double> score(const DataSet &ds, bool use_purity = false, bool quiet = false)
std::vector<double> score(const std::vector<Event> &events, bool use_purity = false, bool quiet = false)
double score_one(const boost::python::list &vals, bool use_purity)
PyObject *score_DataSet(const DataSet &ds, bool use_purity, bool quiet)

Public Static Functions

static double get_epsilon()
static void set_epsilon(double epsilon)

Protected Functions

virtual double base_score(const Scoreable &s, bool use_purity) const = 0

Protected Attributes

std::vector<std::string> m_feature_names
int m_n_features

Protected Static Attributes

static double m_EPS = numeric_limits<double>::epsilon()

Friends

friend struct DTModel_pickle_suite
friend struct BDTModel_pickle_suite
class NonlinearHistogram : public Histogram

Public Functions

explicit NonlinearHistogram(const std::vector<double> &bin_edges)
NonlinearHistogram(const int n, const std::vector<double> values, bool presorted = false)
NonlinearHistogram(const int n, const std::vector<double> values, const std::vector<double> weights, bool presorted = false)
~NonlinearHistogram()
virtual double count(int i) const
virtual std::vector<double>::const_iterator begin() const
virtual std::vector<double>::const_iterator end() const
virtual double min_val() const
virtual double max_val() const
virtual int n_bins() const
virtual void fill(const std::vector<double> &values, const std::vector<double> &weights)
void fill_presorted(const std::vector<double> &sorted_values, const std::vector<double> &sorted_weights)
virtual int index_for_value(double value) const
virtual double value_for_index(int i) const
void write(std::ostream &os) const

Public Static Functions

static std::vector<std::pair<double, double>> get_sorted_values_weights(const std::vector<double> values, const std::vector<double> weights)
static std::pair<std::vector<double>, std::vector<double>> get_pair_sorted_values_weights(const std::vector<double> values, const std::vector<double> weights)
static std::vector<double> get_ntile_boundaries(const int n, const std::vector<double> values, const std::vector<double> weights)

Private Types

typedef std::vector<double> dlist
typedef dlist::iterator dlist_iter
typedef dlist::const_iterator dlist_citer
typedef std::vector<std::pair<double, double>> pairlist
typedef pairlist::const_iterator pairlist_citer

Private Members

std::vector<double> m_bin_edges
double m_underflow
double m_overflow
std::vector<double> m_bin_values

Private Static Functions

static std::vector<double> get_ntile_boundaries_presorted(const int n, const std::vector<double> sorted_values, const std::vector<double> sorted_weights)
template<typename T>
class Notifier
#include <notifier.hpp>

Public Functions

inline Notifier(const std::string &msg, T max, std::ostream &stream = std::cerr, bool overwrite = true)
inline void update(const T &amount)
inline void finish()

Protected Attributes

char m_first
std::string m_msg
T m_max
std::ostream &m_stream
int m_amount_width
std::string m_last
class Pruner
#include <pruner.hpp>

Subclassed by CostComplexityPruner, ErrorPruner, SameLeafPruner

Public Functions

virtual ~Pruner()
virtual void prune(boost::shared_ptr<DTModel> tree) = 0
class RandomSampler
#include <random_sampler.hpp>

Public Functions

RandomSampler(int seed = 0)
template<typename T>
inline std::vector<T> sample(const unsigned n, const std::vector<T> &vec, const bool replace = false)
template<typename T, typename T2>
inline std::vector<T> sample_range(const unsigned n, const T2 &i1, const T2 &i2 = 0, const bool replace = false)

Private Members

gsl_rng *m_rng
template<typename EventType>
class RealScoreable : public Scoreable
#include <model.hpp>

Public Functions

inline RealScoreable(const EventType &event)
inline virtual ~RealScoreable()
inline virtual double operator[](size_type i) const
inline virtual size_type size() const

Private Members

const EventType &m_event
class SameLeafPruner : public Pruner
#include <pruner.hpp>

Public Functions

SameLeafPruner()
virtual ~SameLeafPruner()
virtual void prune(boost::shared_ptr<DTModel> tree)

Private Functions

void prune_node(boost::shared_ptr<DTNode> node)
class Scoreable
#include <model.hpp>

Subclassed by RealScoreable< EventType >

Public Functions

virtual ~Scoreable()
inline bool all_finite() const
virtual double operator[](size_type i) const = 0
virtual size_type size() const = 0

Protected Types

typedef std::vector<double>::size_type size_type
struct SepCrossEntropy : public SepFunc
#include <dtlearner.hpp>

Public Functions

inline virtual double operator()(double p) const
inline virtual std::string separation_type() const
struct SepFunc
#include <dtlearner.hpp>

Subclassed by SepCrossEntropy, SepGini, SepMisclassError

Public Functions

virtual double operator()(double p) const = 0
virtual std::string separation_type() const = 0
inline virtual ~SepFunc()
struct SepGini : public SepFunc
#include <dtlearner.hpp>

Public Functions

inline virtual double operator()(double p) const
inline virtual std::string separation_type() const
struct SepMisclassError : public SepFunc
#include <dtlearner.hpp>

Public Functions

inline virtual double operator()(double p) const
inline virtual std::string separation_type() const
class VineLearner : public Learner
#include <vinelearner.hpp>

Public Functions

VineLearner(const std::string &vine_feature, const double vine_feature_min, const double vine_feature_max, const double vine_feature_width, const double vine_feature_step, boost::shared_ptr<Learner> learner)
virtual ~VineLearner()
bool quiet() const
std::string vine_feature() const
double vine_feature_min() const
double vine_feature_max() const
double vine_feature_width() const
double vine_feature_step() const
void quiet(bool val)
void vine_feature(const std::string &vine_feature)
void vine_feature_min(const double vine_feature_min)
void vine_feature_max(const double vine_feature_max)
void vine_feature_width(const double vine_feature_width)
void vine_feature_step(const double vine_feature_step)
boost::shared_ptr<Learner> learner()
virtual boost::shared_ptr<Model> train_given_everything(const std::vector<Event> &sig, const std::vector<Event> &bg, const std::vector<double> &init_sig_weights, const std::vector<double> &init_bg_weights) const

Protected Attributes

std::string m_vine_feature
double m_vine_feature_min
double m_vine_feature_max
double m_vine_feature_width
double m_vine_feature_step
size_t m_vine_feature_i
bool m_quiet
boost::shared_ptr<Learner> m_learner

Friends

friend class VineLearner_pickle_suite
class VineModel : public Model
#include <vinemodel.hpp>

Public Functions

VineModel(const std::vector<std::string> &feature_names, const std::string &vine_feature, const std::vector<double> bin_mins, const std::vector<double> bin_maxs, const std::vector<boost::shared_ptr<Model>> models)
virtual ~VineModel()
VineModel(const boost::python::list &feature_names, const std::string &vine_feature, const boost::python::list &bin_mins, const boost::python::list &bin_maxs, const boost::python::list &models)
std::vector<double> variable_importance(bool sep_weighted) const
boost::python::dict variable_importance_py(bool sep_weighted) const

Protected Functions

virtual double base_score(const Scoreable &e, bool use_purity) const

Protected Attributes

std::string m_vine_feature
size_t m_vine_feature_i
std::vector<double> m_bin_mins
std::vector<double> m_bin_maxs
std::vector<boost::shared_ptr<Model>> m_models

Friends

friend struct VineModel_pickle_suite
struct VineModel_pickle_suite : public pickle_suite
#include <vinemodel.hpp>

Public Static Functions

static boost::python::tuple getinitargs(const VineModel &m)
namespace np

Functions

template<typename T>
vector<T> array_to_vector(PyObject *a)
template<typename T>
std::vector<T> list_to_vector(const boost::python::list &l)
template<typename T>
boost::python::list vector_to_list(const vector<T> &v)
template<typename T>
PyObject *vector_to_array(const vector<T> &v)
template<typename T, typename T2>
vector<T> range(T2 lower, T2 upper = 0)
template<typename T>
vector<T> ones(int n)
template<typename T>
vector<T> zeros(int n)
template<typename T>
T sum(const vector<T> &v)
template<typename T>
T max(const vector<T> &v)
template<typename T>
T max(const vector<T> &v, const vector<int> &idx)
template<typename T>
T min(const vector<T> &v)
template<typename T>
T min(const vector<T> &v, const vector<int> &idx)
template<typename T>
int index(const vector<T> &v, const T &t)
template<typename T, typename T2>
vector<bool> lt(const vector<T> &v, const T2 &t)
template<typename T, typename T2>
vector<bool> gt(const vector<T> &v, const T2 &t)
template<typename T, typename T2>
vector<bool> lte(const vector<T> &v, const T2 &t)
template<typename T, typename T2>
vector<bool> gte(const vector<T> &v, const T2 &t)
template<typename T1, typename T2>
bool dims_match(const vector<T1> &a, const vector<T2> &b)
template<typename func, typename T>
vector<typename func::result_type> operate(const vector<T> &a, const vector<T> &b)
template<typename func, typename T, typename T2>
vector<typename func::result_type> operate(const vector<T> &a, const T2 &b)
template<typename T, typename T2>
vector<T> add(const vector<T> &a, const T2 &b)
template<typename T, typename T2>
vector<T> sub(const vector<T> &a, const T2 &b)
template<typename T, typename T2>
vector<T> mul(const vector<T> &a, const T2 &b)
template<typename T, typename T2>
vector<T> div(const vector<T> &a, const T2 &b)
template<typename T, typename T2>
vector<bool> eq(const vector<T> &a, const T2 &b)
template<typename T>
T prod(const vector<T> &v)
template<typename T>
vector<T> exp(const vector<T> &v)
template<typename T>
vector<bool> isfinite(const vector<T> &v)
template<typename Tout, typename T>
vector<Tout> conv(const vector<T> &v)
template<typename T1, typename T2>
vector<T1> subscript(const vector<T1> v, const vector<T2> indices)
template<typename T>
vector<T> subscript(const vector<T> v, const vector<bool> keep)
template<typename T>
std::string stringify(const vector<T> v)
namespace std

STL namespace.

file bdtlearner.cpp
#include <Python.h>
#include “bdtlearner.hpp
#include “np.hpp
#include “notifier.hpp
#include <iostream>
#include <limits>
#include <boost/make_shared.hpp>
#include <boost/pointer_cast.hpp>

Functions

void export_bdtlearner()
file bdtlearner.hpp
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>
#include “boost_python.hpp
#include “bdtmodel.hpp
#include “dataset.hpp
#include “dtlearner.hpp
#include “learner.hpp
#include “pruner.hpp

Functions

void export_bdtlearner()
file bdtmodel.cpp
#include <Python.h>
#include “bdtmodel.hpp
#include “np.hpp
#include <cmath>
#include <boost/make_shared.hpp>

Functions

void export_bdtmodel()
file bdtmodel.hpp
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>
#include “boost_python.hpp
#include “dtmodel.hpp
#include “model.hpp

Functions

void export_bdtmodel()
file boost_python.hpp
#include <boost/python.hpp>
file dataset.cpp
#include “dataset.hpp
#include “np.hpp
#include <cmath>
#include <boost/make_shared.hpp>
#include <numpy/ndarrayobject.h>

Defines

PY_ARRAY_UNIQUE_SYMBOL
NO_IMPORT_ARRY

Functions

void export_dataset()
file dataset.hpp
#include <cmath>
#include <iostream>
#include <vector>
#include <string>
#include “boost_python.hpp

Functions

void export_dataset()
file dtlearner.cpp
#include <Python.h>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include “dtlearner.hpp
#include “linear_histogram.hpp
#include “nonlinear_histogram.hpp
#include “np.hpp
#include <limits>
#include <map>

Functions

void export_dtlearner()
file dtlearner.hpp
#include <string>
#include <vector>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>
#include “boost_python.hpp
#include “dataset.hpp
#include “dtmodel.hpp
#include “learner.hpp
#include “random_sampler.hpp

Functions

void export_dtlearner()
file dtmodel.cpp
#include <Python.h>
#include “dtmodel.hpp
#include “np.hpp
#include <algorithm>
#include <iostream>
#include <limits>
#include <numeric>
#include <queue>
#include <boost/make_shared.hpp>
#include <boost/math/special_functions/fpclassify.hpp>

Functions

void export_dtmodel()
file dtmodel.hpp
#include <string>
#include <vector>
#include “boost_python.hpp
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include “model.hpp

Functions

void export_dtmodel()
file histogram.cpp
#include “linear_histogram.hpp
#include <vector>
#include “np.hpp
file histogram.hpp
#include <cmath>
#include <vector>
file learner.cpp
#include <Python.h>
#include “learner.hpp
#include “np.hpp
#include <algorithm>

Functions

void export_learner()
file learner.hpp
#include <vector>
#include <string>
#include “boost_python.hpp
#include “dataset.hpp
#include “model.hpp

Functions

void export_learner()
file linear_histogram.cpp
#include “linear_histogram.hpp
#include “np.hpp
file linear_histogram.hpp
#include <cmath>
#include <vector>
#include “histogram.hpp
file model.cpp
#include <Python.h>
#include “model.hpp
#include <cmath>
#include <limits>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include “np.hpp
#include “notifier.hpp

Functions

void export_model()
file model.hpp
#include <cstdlib>
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include “boost_python.hpp
#include “dataset.hpp

Functions

void export_model()
template<typename EventType>
RealScoreable<EventType> make_scoreable(const EventType &event)
file nonlinear_histogram.cpp
#include “nonlinear_histogram.hpp
#include <iostream>
#include “np.hpp

Functions

template<typename T>
vector<T> sorted(const vector<T> &v)
file nonlinear_histogram.hpp
#include <algorithm>
#include <cassert>
#include <cmath>
#include <ostream>
#include <vector>
#include <utility>
#include “histogram.hpp
file notifier.hpp
#include <iomanip>
#include <iostream>
#include <sstream>
file np.hpp
#include <cstdlib>
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#include “boost_python.hpp
#include <numpy/ndarrayobject.h>

Defines

NPY_NO_DEPRECATED_API
PY_ARRAY_UNIQUE_SYMBOL
NO_IMPORT_ARRAY
file pruner.cpp
#include <Python.h>
#include “pruner.hpp
#include <map>
#include <numeric>
#include <queue>

Functions

void export_pruners()
file pruner.hpp
#include <boost/shared_ptr.hpp>
#include “dtmodel.hpp

Functions

void export_pruners()
file pybdt.cpp
#include <cstdlib>
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#include <boost/assign/list_of.hpp>
#include <boost/assign/std/vector.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/tuple/tuple.hpp>
#include “boost_python.hpp
#include <numpy/ndarrayobject.h>
#include “np.hpp
#include “dataset.hpp
#include “model.hpp
#include “learner.hpp
#include “dtmodel.hpp
#include “dtlearner.hpp
#include “bdtmodel.hpp
#include “bdtlearner.hpp
#include “vinemodel.hpp
#include “vinelearner.hpp

Defines

NPY_NO_DEPRECATED_API
PY_ARRAY_UNIQUE_SYMBOL

Functions

static PyObject *hack_import_array()
file random_sampler.cpp
#include “random_sampler.hpp
file random_sampler.hpp
#include <set>
#include <vector>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>
#include “np.hpp
file vinelearner.cpp
#include <Python.h>
#include <stdexcept>
#include “vinelearner.hpp
#include “np.hpp
#include “notifier.hpp
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/pointer_cast.hpp>
#include “vinemodel.hpp

Functions

void export_vinelearner()
file vinelearner.hpp
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>
#include “boost_python.hpp
#include “dataset.hpp
#include “learner.hpp

Functions

void export_vinelearner()
file vinemodel.cpp
#include <Python.h>
#include “vinemodel.hpp
#include “np.hpp
#include <iostream>
#include <limits>
#include <boost/math/special_functions/fpclassify.hpp>

Functions

void export_vinemodel()
file vinemodel.hpp
#include <string>
#include <vector>
#include <utility>
#include “boost_python.hpp
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include “model.hpp

Functions

void export_vinemodel()
dir icetray
dir private
dir pybdt
dir pybdt