gum::learning::BNDatabaseGenerator< GUM_SCALAR > Class Template Reference

#include <BNDatabaseGenerator.h>

Inheritance diagram for gum::learning::BNDatabaseGenerator< GUM_SCALAR >:

Collaboration diagram for gum::learning::BNDatabaseGenerator< GUM_SCALAR >:

Public Types
enum class	DiscretizedLabelMode : char { INTERVAL , MEDIAN , RANDOM }

Public Member Functions
Constructors / Destructors
	BNDatabaseGenerator (const BayesNet< GUM_SCALAR > &bn)
	default constructor
	~BNDatabaseGenerator ()
	destructor
Accessors / Modifiers
double	drawSamples (Size nbSamples)
	generate and stock database, returns log2likelihood using ProgressNotifier as notification
double	drawSamples (Size nbSamples, const gum::Instantiation &evs, int timeout=300)
	Generate and stock the part of the database compatible with the evidence, returns log2likelihood using ProgressNotifier as notification.
void	setDiscretizedLabelModeRandom ()
	set the behaviour of sampling for discretized variable to uniformly draw double value
void	setDiscretizedLabelModeMedian ()
	set the behaviour of sampling for discretized variable to deterministic select double median of intervalls
void	setDiscretizedLabelModeInterval ()
	set the behaviour of sampling for discretized variable to select the label : "[min,max["
void	toCSV (const std::string &csvFileURL, bool useLabels=true, bool append=false, std::string csvSeparator=",", bool checkOnAppend=false) const
	generates csv representing the generated database
DatabaseTable	toDatabaseTable (bool useLabels=true) const
	generates a DatabaseVectInRAM
std::vector< std::vector< Idx > >	database () const
	generates database according to bn into a std::vector
Size	samplesNbRows () const
	generate and stock database, returns log2likelihood using ProgressNotifier as notification
Size	samplesNbCols () const
	generate and stock database, returns log2likelihood using ProgressNotifier as notification
Idx	samplesAt (Idx row, Idx col) const
	generate and stock database, returns log2likelihood using ProgressNotifier as notification
std::string	samplesLabelAt (Idx row, Idx col) const
	generate and stock database, returns log2likelihood using ProgressNotifier as notification
void	setVarOrder (const std::vector< Idx > &varOrder)
	change columns order
void	setVarOrder (const std::vector< std::string > &varOrder)
	change columns order using variable names
void	setVarOrderFromCSV (const std::string &csvFileURL, const std::string &csvSeparator=",")
	change columns order according to a csv file
void	setTopologicalVarOrder ()
	set columns in topoligical order
void	setAntiTopologicalVarOrder ()
	set columns in antiTopoligical order
void	setRandomVarOrder ()
	set columns in random order
std::vector< Idx >	varOrder () const
	returns variable order indexes
std::vector< std::string >	varOrderNames () const
	returns variable order.
double	log2likelihood () const
	returns log2Likelihood of generated samples
const BayesNet< GUM_SCALAR > &	bn (void)
	return const ref to the Bayes Net

Public Attributes
Signaler2< Size, double >	onProgress
	Progression (percent) and time.
Signaler1< const std::string & >	onStop
	with a possible explanation for stopping

Private Member Functions
std::string	_label_ (const std::vector< Idx > &row, const DiscreteVariable &v, Idx i) const
	return the final string for a label (taking into account the behavior for DiscretizedVariable) from a row
std::vector< Idx >	_varOrderFromCSV_ (const std::string &csvFileURL, const std::string &csvSeparator=",") const
	returns varOrder from a csv file
std::vector< Idx >	_varOrderFromCSV_ (std::ifstream &csvFile, const std::string &csvSeparator=",") const
	returns varOrder from a csv file
	BNDatabaseGenerator (const BNDatabaseGenerator &)=delete
	BNDatabaseGenerator (BNDatabaseGenerator &&)=delete
BNDatabaseGenerator &	operator= (const BNDatabaseGenerator &)=delete
BNDatabaseGenerator &	operator= (BNDatabaseGenerator &&)=delete

Private Attributes
DiscretizedLabelMode	_discretizedLabelMode_
const BayesNet< GUM_SCALAR > &	_bn_
	Bayesian network.
Bijection< std::string, NodeId >	_names2ids_
	bijection nodes names
Size	_nbVars_
	number of variables
std::vector< std::vector< Idx > >	_database_
	generated database
std::vector< Idx >	_varOrder_
	variable order in generated database
bool	_drawnSamples_ = false
	whether drawSamples has been already called.
double	_log2likelihood_ = 0
	log2Likelihood of generated samples

Detailed Description

template<typename GUM_SCALAR>
class gum::learning::BNDatabaseGenerator< GUM_SCALAR >

Definition at line 100 of file BNDatabaseGenerator.h.

Member Enumeration Documentation

DiscretizedLabelMode

template<typename GUM_SCALAR>

enum class gum::learning::BNDatabaseGenerator::DiscretizedLabelMode : char

strong

Enumerator
INTERVAL
MEDIAN
RANDOM

Definition at line 102 of file BNDatabaseGenerator.h.

: char { INTERVAL, MEDIAN, RANDOM };

Constructor & Destructor Documentation

BNDatabaseGenerator() [1/3]

template<typename GUM_SCALAR>

gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator ( const BayesNet< GUM_SCALAR > & bn )

explicit

default constructor

Definition at line 57 of file BNDatabaseGenerator_tpl.h.

                                                                                         :
      _bn_(bn) {
    GUM_CONSTRUCTOR(BNDatabaseGenerator)
 
    // get the node names => they will serve as ids
    NodeId id = 0;
    for (const auto& var: _bn_.dag()) {
      auto name = _bn_.variable(var).name();
      _names2ids_.insert(name, var);
      ++id;
    }
    _nbVars_ = id;
    _varOrder_.resize(_nbVars_);
    _discretizedLabelMode_ = DiscretizedLabelMode::RANDOM;
    std::iota(_varOrder_.begin(), _varOrder_.end(), (Idx)0);
  }

References BNDatabaseGenerator(), _bn_, _discretizedLabelMode_, _names2ids_, _nbVars_, _varOrder_, bn(), and RANDOM.

Referenced by BNDatabaseGenerator(), BNDatabaseGenerator(), BNDatabaseGenerator(), ~BNDatabaseGenerator(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

~BNDatabaseGenerator()

template<typename GUM_SCALAR>

gum::learning::BNDatabaseGenerator< GUM_SCALAR >::~BNDatabaseGenerator

(

)

destructor

Definition at line 76 of file BNDatabaseGenerator_tpl.h.

                                                          {
    GUM_DESTRUCTOR(BNDatabaseGenerator)
  }

References BNDatabaseGenerator().

Here is the call graph for this function:

BNDatabaseGenerator() [2/3]

template<typename GUM_SCALAR>

gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator ( const BNDatabaseGenerator< GUM_SCALAR > & )

privatedelete

References BNDatabaseGenerator().

Here is the call graph for this function:

BNDatabaseGenerator() [3/3]

template<typename GUM_SCALAR>

gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator ( BNDatabaseGenerator< GUM_SCALAR > && )

privatedelete

References BNDatabaseGenerator().

Here is the call graph for this function:

Member Function Documentation

_label_()

template<typename GUM_SCALAR>

std::string gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_label_ ( const std::vector< Idx > & row, const DiscreteVariable & v, Idx i ) const

private

return the final string for a label (taking into account the behavior for DiscretizedVariable) from a row

Definition at line 293 of file BNDatabaseGenerator_tpl.h.

                                                                                            {
    if (v.varType() == VarType::DISCRETIZED) {
      switch (_discretizedLabelMode_) {
        case DiscretizedLabelMode::MEDIAN : return std::to_string(v.numerical(row.at(i)));
        case DiscretizedLabelMode::RANDOM :
          return std::to_string(static_cast< const IDiscretizedVariable& >(v).draw(row.at(i)));
        case DiscretizedLabelMode::INTERVAL : return v.label(row.at(i));
      }
    }
 
    return v.label(row.at(i));
  }

References _discretizedLabelMode_, gum::DISCRETIZED, INTERVAL, gum::DiscreteVariable::label(), MEDIAN, gum::DiscreteVariable::numerical(), RANDOM, and gum::DiscreteVariable::varType().

Referenced by samplesLabelAt(), and toDatabaseTable().

Here is the call graph for this function:

Here is the caller graph for this function:

_varOrderFromCSV_() [1/2]

template<typename GUM_SCALAR>

std::vector< Idx > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_varOrderFromCSV_ ( const std::string & csvFileURL, const std::string & csvSeparator = "," ) const

private

returns varOrder from a csv file

Definition at line 471 of file BNDatabaseGenerator_tpl.h.

                                                                                                {
    std::ifstream      csvFile(csvFileURL);
    std::vector< Idx > varOrder;
    if (csvFile) {
      varOrder = _varOrderFromCSV_(csvFile, csvSeparator);
      csvFile.close();
    } else {
      GUM_ERROR(NotFound, "csvFileURL does not exist")
    }
 
    return varOrder;
  }

References _varOrderFromCSV_(), GUM_ERROR, and varOrder().

Referenced by _varOrderFromCSV_(), setVarOrderFromCSV(), and toCSV().

Here is the call graph for this function:

Here is the caller graph for this function:

_varOrderFromCSV_() [2/2]

template<typename GUM_SCALAR>

std::vector< Idx > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_varOrderFromCSV_ ( std::ifstream & csvFile, const std::string & csvSeparator = "," ) const

private

returns varOrder from a csv file

Definition at line 488 of file BNDatabaseGenerator_tpl.h.

                                                                                                {
    std::string                line;
    std::vector< std::string > header_found;
    header_found.reserve(_nbVars_);
    while (std::getline(csvFile, line)) {
      std::size_t i   = 0;
      auto        pos = line.find(csvSeparator);
      while (pos != std::string::npos) {
        header_found.push_back(line.substr(i, pos - i));
        pos += csvSeparator.length();
        i   = pos;
        pos = line.find(csvSeparator, pos);
 
        if (pos == std::string::npos) header_found.push_back(line.substr(i, line.length()));
      }
      break;
    }
 
    std::vector< Size > varOrder;
    varOrder.reserve(_nbVars_);
 
    for (const auto& hf: header_found) {
      varOrder.push_back(_names2ids_.second(hf));
    }
 
    return varOrder;
  }

References _names2ids_, _nbVars_, and varOrder().

Here is the call graph for this function:

bn()

template<typename GUM_SCALAR>

const BayesNet< GUM_SCALAR > & gum::learning::BNDatabaseGenerator< GUM_SCALAR >::bn ( void )

inline

return const ref to the Bayes Net

Definition at line 209 of file BNDatabaseGenerator.h.

{ return _bn_; };

References _bn_.

Referenced by BNDatabaseGenerator().

Here is the caller graph for this function:

database()

template<typename GUM_SCALAR>

std::vector< std::vector< Idx > > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::database

(

)

const

generates database according to bn into a std::vector

returns database using specified data order

Warning

: makes a copy of the whole database

Definition at line 358 of file BNDatabaseGenerator_tpl.h.

                                                                                  {
    if (!_drawnSamples_) GUM_ERROR(OperationNotAllowed, "drawSamples() must be called first.")
 
    auto db(_database_);
    for (Idx i = 0; i < _database_.size(); ++i) {
      for (Idx j = 0; j < _nbVars_; ++j) {
        db.at(i).at(j) = (Idx)_database_.at(i).at(_varOrder_.at(j));
      }
    }
    return db;
  }

References _database_, _drawnSamples_, _nbVars_, _varOrder_, and GUM_ERROR.

drawSamples() [1/2]

template<typename GUM_SCALAR>

double gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples

(

Size

nbSamples

)

generate and stock database, returns log2likelihood using ProgressNotifier as notification

draw instances from bn

Definition at line 82 of file BNDatabaseGenerator_tpl.h.

                                                                      {
    const Instantiation inst;
    return drawSamples(nbSamples, inst);
  }

References drawSamples().

Referenced by drawSamples().

Here is the call graph for this function:

Here is the caller graph for this function:

drawSamples() [2/2]

template<typename GUM_SCALAR>

double gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples	(	Size	nbSamples,
		const gum::Instantiation &	evs,
		int	timeout = 300 )

Generate and stock the part of the database compatible with the evidence, returns log2likelihood using ProgressNotifier as notification.

draw instances from bn

Warning

nbSamples is not the number of generated samples but the size of the filtered database. It may happen that the evidence is very rare (or even impossible). In that case, the rejection sampling process may be very slow (or even infinite). In that case, the timeout is mandatory.

@parameter nbSamples: the size of the filtered database. @parameter evs: the evidence. @parameter timeout: the maximum time in seconds to wait for the generation of the samples. If the timeout is reached, the function returns the log2likelihood of the generated samples. if timeout=0, no timeout are watched and the function may run indefinitely.

Definition at line 89 of file BNDatabaseGenerator_tpl.h.

                                                                                      {
    int progress = 0;
 
    if (onProgress.hasListener()) { GUM_EMIT2(onProgress, progress, 0.0); }
 
    _database_.clear();
    _database_.resize(nbSamples);
    for (auto& row: _database_) {
      row.resize(_nbVars_);
    }
    // get the order in which the nodes will be sampled
    const auto         topOrder = _bn_.topologicalOrder();
    gum::Instantiation particule;
 
    // create instantiations in advance
    for (NodeId node = 0; node < _nbVars_; ++node)
      particule.add(_bn_.variable(node));
 
    gum::Timer timer;
    timer.reset();
 
    // perform the sampling
    _log2likelihood_ = 0;
    Idx idSample     = 0;
    while (idSample < nbSamples) {
      if (onProgress.hasListener()) {
        auto p = int((idSample * 100) / nbSamples);
        if (p != progress) {
          progress = p;
          GUM_EMIT2(onProgress, progress, timer.step());
        }
      }
      std::vector< Idx >& sample = _database_.at(idSample);
      bool                reject = false;
      for (Idx rank = 0; rank < _nbVars_; ++rank) {
        const NodeId node = topOrder[rank];
        const auto&  var  = _bn_.variable(node);
        const auto&  cpt  = _bn_.cpt(node);
 
        const double nb    = gum::randomProba();
        double       cumul = 0.0;
        for (particule.setFirstVar(var); !particule.end(); particule.incVar(var)) {
          cumul += cpt[particule];
          if (cumul >= nb) break;
        }
        if (particule.end()) particule.setLastVar(var);
 
        if ((!evs.empty()) && evs.contains(var) && (evs.val(var) != particule.val(var))) {
          reject = true;
          break;
        }
 
        sample.at(node) = particule.val(var);
        _log2likelihood_ += std::log2(_bn_.cpt(node)[particule]);
      }
      if (timeout > 0 && timer.step() > timeout) { break; }
      if (reject) { continue; }
      idSample++;
    }
 
    if (idSample > 0) {
      if (idSample < nbSamples) _database_.resize(idSample);
    } else {
      _database_.clear();
    }
    _drawnSamples_ = true;
 
    if (onProgress.hasListener()) {
      std::stringstream ss;
      ss << "Database of size " << idSample << "(" << nbSamples << ") generated in " << timer.step()
         << " seconds. Log2likelihood : " << _log2likelihood_;
      GUM_EMIT1(onStop, ss.str());
    }
 
    return _log2likelihood_;
  }

References _bn_, _database_, _drawnSamples_, _log2likelihood_, _nbVars_, gum::Instantiation::add(), gum::Instantiation::contains(), gum::Instantiation::empty(), gum::Instantiation::end(), GUM_EMIT1, GUM_EMIT2, gum::Instantiation::incVar(), gum::ProgressNotifier::onProgress, gum::ProgressNotifier::onStop, gum::randomProba(), gum::Timer::reset(), gum::Instantiation::setFirstVar(), gum::Instantiation::setLastVar(), gum::Timer::step(), and gum::Instantiation::val().

Here is the call graph for this function:

log2likelihood()

template<typename GUM_SCALAR>

double gum::learning::BNDatabaseGenerator< GUM_SCALAR >::log2likelihood

(

)

const

returns log2Likelihood of generated samples

Definition at line 463 of file BNDatabaseGenerator_tpl.h.

                                                                 {
    if (!_drawnSamples_) { GUM_ERROR(OperationNotAllowed, "drawSamples() must be called first.") }
    return _log2likelihood_;
  }

References _drawnSamples_, _log2likelihood_, and GUM_ERROR.

operator=() [1/2]

template<typename GUM_SCALAR>

BNDatabaseGenerator & gum::learning::BNDatabaseGenerator< GUM_SCALAR >::operator= ( BNDatabaseGenerator< GUM_SCALAR > && )

privatedelete

References BNDatabaseGenerator().

Here is the call graph for this function:

operator=() [2/2]

template<typename GUM_SCALAR>

BNDatabaseGenerator & gum::learning::BNDatabaseGenerator< GUM_SCALAR >::operator= ( const BNDatabaseGenerator< GUM_SCALAR > & )

privatedelete

References BNDatabaseGenerator().

Here is the call graph for this function:

samplesAt()

template<typename GUM_SCALAR>

INLINE Idx gum::learning::BNDatabaseGenerator< GUM_SCALAR >::samplesAt	(	Idx	row,
		Idx	col ) const

generate and stock database, returns log2likelihood using ProgressNotifier as notification

draw instances from bn

Definition at line 183 of file BNDatabaseGenerator_tpl.h.

                                                                                {
    if (!_drawnSamples_) { GUM_ERROR(OperationNotAllowed, "drawSamples() must be called first.") }
    return _database_.at(row).at(_varOrder_.at(col));
  }

References _database_, _drawnSamples_, _varOrder_, and GUM_ERROR.

samplesLabelAt()

template<typename GUM_SCALAR>

INLINE std::string gum::learning::BNDatabaseGenerator< GUM_SCALAR >::samplesLabelAt	(	Idx	row,
		Idx	col ) const

generate and stock database, returns log2likelihood using ProgressNotifier as notification

draw instances from bn

Definition at line 189 of file BNDatabaseGenerator_tpl.h.

                                                                                           {
    if (!_drawnSamples_) { GUM_ERROR(OperationNotAllowed, "drawSamples() must be called first.") }
    const auto j = _varOrder_.at(col);
    return _label_(_database_.at(row), _bn_.variable(j), j);
  }

References _bn_, _database_, _drawnSamples_, _label_(), _varOrder_, and GUM_ERROR.

Here is the call graph for this function:

samplesNbCols()

template<typename GUM_SCALAR>

INLINE Size gum::learning::BNDatabaseGenerator< GUM_SCALAR >::samplesNbCols

(

)

const

generate and stock database, returns log2likelihood using ProgressNotifier as notification

draw instances from bn

Definition at line 176 of file BNDatabaseGenerator_tpl.h.

                                                                     {
    if (!_drawnSamples_) { GUM_ERROR(OperationNotAllowed, "drawSamples() must be called first.") }
 
    return _nbVars_;
  }

References _drawnSamples_, _nbVars_, and GUM_ERROR.

samplesNbRows()

template<typename GUM_SCALAR>

INLINE Size gum::learning::BNDatabaseGenerator< GUM_SCALAR >::samplesNbRows

(

)

const

generate and stock database, returns log2likelihood using ProgressNotifier as notification

draw instances from bn

Definition at line 169 of file BNDatabaseGenerator_tpl.h.

                                                                     {
    if (!_drawnSamples_) { GUM_ERROR(OperationNotAllowed, "drawSamples() must be called first.") }
 
    return _database_.size();
  }

References _database_, _drawnSamples_, and GUM_ERROR.

setAntiTopologicalVarOrder()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setAntiTopologicalVarOrder

(

)

set columns in antiTopoligical order

set columns in antiTopological order

Definition at line 421 of file BNDatabaseGenerator_tpl.h.

                                                                     {
    std::vector< Idx > varOrder;
    varOrder.reserve(_nbVars_);
    for (const auto& v: _bn_.topologicalOrder()) {
      varOrder.push_back(v);
    }
    std::reverse(varOrder.begin(), varOrder.end());
    setVarOrder(varOrder);
  }

References _bn_, _nbVars_, setVarOrder(), and varOrder().

Here is the call graph for this function:

setDiscretizedLabelModeInterval()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setDiscretizedLabelModeInterval

(

)

set the behaviour of sampling for discretized variable to select the label : "[min,max["

Definition at line 206 of file BNDatabaseGenerator_tpl.h.

                                                                          {
    _discretizedLabelMode_ = DiscretizedLabelMode::INTERVAL;
  }

References _discretizedLabelMode_, and INTERVAL.

setDiscretizedLabelModeMedian()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setDiscretizedLabelModeMedian

(

)

set the behaviour of sampling for discretized variable to deterministic select double median of intervalls

Definition at line 201 of file BNDatabaseGenerator_tpl.h.

                                                                        {
    _discretizedLabelMode_ = DiscretizedLabelMode::MEDIAN;
  }

References _discretizedLabelMode_, and MEDIAN.

setDiscretizedLabelModeRandom()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setDiscretizedLabelModeRandom

(

)

set the behaviour of sampling for discretized variable to uniformly draw double value

Warning

: each call to toCSV or toDatabase that use labels will then generate different values

: this is the default behaviour

Definition at line 196 of file BNDatabaseGenerator_tpl.h.

                                                                        {
    _discretizedLabelMode_ = DiscretizedLabelMode::RANDOM;
  }

References _discretizedLabelMode_, and RANDOM.

setRandomVarOrder()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setRandomVarOrder

(

)

set columns in random order

Definition at line 433 of file BNDatabaseGenerator_tpl.h.

                                                            {
    std::vector< std::string > varOrder;
    varOrder.reserve(_bn_.size());
    for (const auto& var: _bn_.dag()) {
      varOrder.push_back(_bn_.variable(var).name());
    }
    std::shuffle(varOrder.begin(), varOrder.end(), gum::randomGenerator());
    setVarOrder(varOrder);
  }

References _bn_, gum::randomGenerator(), setVarOrder(), and varOrder().

Here is the call graph for this function:

setTopologicalVarOrder()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setTopologicalVarOrder

(

)

set columns in topoligical order

set columns in Topological order

Definition at line 410 of file BNDatabaseGenerator_tpl.h.

                                                                 {
    std::vector< Idx > varOrder;
    varOrder.reserve(_nbVars_);
    for (const auto& v: _bn_.topologicalOrder()) {
      varOrder.push_back(v);
    }
    setVarOrder(varOrder);
  }

References _bn_, _nbVars_, setVarOrder(), and varOrder().

Here is the call graph for this function:

setVarOrder() [1/2]

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder

(

const std::vector< Idx > &

varOrder

)

change columns order

Definition at line 372 of file BNDatabaseGenerator_tpl.h.

                                                                                      {
    if (varOrder.size() != _nbVars_)
      GUM_ERROR(FatalError, "varOrder's size must be equal to the number of variables")
 
    std::vector< bool > usedVars(_nbVars_, false);
    for (const auto& i: varOrder) {
      if (i >= _nbVars_) GUM_ERROR(FatalError, "varOrder contains invalid variables")
      if (usedVars.at(i)) GUM_ERROR(FatalError, "varOrder must not have repeated variables")
      usedVars.at(i) = true;
    }
 
    if (std::find(usedVars.begin(), usedVars.end(), false) != usedVars.end()) {
      GUM_ERROR(FatalError, "varOrder must contain all variables")
    }
 
    _varOrder_ = varOrder;
  }

References _nbVars_, _varOrder_, GUM_ERROR, and varOrder().

Referenced by setAntiTopologicalVarOrder(), setRandomVarOrder(), setTopologicalVarOrder(), setVarOrder(), and setVarOrderFromCSV().

Here is the call graph for this function:

Here is the caller graph for this function:

setVarOrder() [2/2]

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder

(

const std::vector< std::string > &

varOrder

)

change columns order using variable names

Definition at line 392 of file BNDatabaseGenerator_tpl.h.

                                                                                            {
    std::vector< Idx > varOrderIdx;
    varOrderIdx.reserve(varOrder.size());
    for (const auto& vname: varOrder) {
      varOrderIdx.push_back(_names2ids_.second(vname));
    }
    setVarOrder(varOrderIdx);
  }

References _names2ids_, setVarOrder(), and varOrder().

Here is the call graph for this function:

setVarOrderFromCSV()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrderFromCSV	(	const std::string &	csvFileURL,
		const std::string &	csvSeparator = "," )

change columns order according to a csv file

Definition at line 403 of file BNDatabaseGenerator_tpl.h.

                                                                                            {
    setVarOrder(_varOrderFromCSV_(csvFileURL, csvSeparator));
  }

References _varOrderFromCSV_(), and setVarOrder().

Here is the call graph for this function:

toCSV()

template<typename GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV	(	const std::string &	csvFileURL,
		bool	useLabels = true,
		bool	append = false,
		std::string	csvSeparator = ",",
		bool	checkOnAppend = false ) const

generates csv representing the generated database

generates database, and writes csv file

Definition at line 212 of file BNDatabaseGenerator_tpl.h.

                                                                                        {
    if (!_drawnSamples_) { GUM_ERROR(OperationNotAllowed, "drawSamples() must be called first.") }
 
    if (csvSeparator.find('\n') != std::string::npos) {
      GUM_ERROR(InvalidArgument, "csvSeparator must not contain end-line characters")
    }
 
    bool includeHeader = true;
    if (append) {
      std::ifstream csvFile(csvFileURL);
      if (csvFile) {
        if (auto varOrder = _varOrderFromCSV_(csvFile, csvSeparator);
            checkOnAppend && varOrder != _varOrder_)
          GUM_ERROR(OperationNotAllowed,
                    "Inconsistent variable order in csvFile when appending. You "
                    "can use setVarOrderFromCSV(url) function to get the right "
                    "order. You could also set parameter checkOnAppend=false if you "
                    "know what you are doing.")
        includeHeader = false;
      }
      csvFile.close();
    }
 
 
    auto ofstreamFlag = append ? std::ofstream::app : std::ofstream::out;
 
    std::ofstream os(csvFileURL, ofstreamFlag);
    bool          firstCol = true;
    if (includeHeader) {
      for (const auto& i: _varOrder_) {
        if (firstCol) {
          firstCol = false;
        } else {
          os << csvSeparator;
        }
        os << _bn_.variable(i).name();
      }
    }
    os << std::endl;
 
    bool firstRow = true;
    for (const auto& row: _database_) {
      if (firstRow) {
        firstRow = false;
      } else {
        os << std::endl;
      }
      firstCol = true;
      for (const auto& i: _varOrder_) {
        if (firstCol) {
          firstCol = false;
        } else {
          os << csvSeparator;
        }
        if (useLabels) {
          const auto& v = _bn_.variable(i);
          if (v.varType() == VarType::DISCRETIZED) {
            switch (_discretizedLabelMode_) {
              case DiscretizedLabelMode::MEDIAN : os << v.numerical(row.at(i)); break;
              case DiscretizedLabelMode::RANDOM :
                os << static_cast< const IDiscretizedVariable& >(v).draw(row.at(i));
                break;
              case DiscretizedLabelMode::INTERVAL : os << v.label(row.at(i)); break;
            }
          } else {
            os << v.label(row.at(i));
          }
        } else {
          os << row[i];
        }
      }
    }
 
    os.close();
  }

References _bn_, _database_, _discretizedLabelMode_, _drawnSamples_, _varOrder_, _varOrderFromCSV_(), gum::DISCRETIZED, GUM_ERROR, INTERVAL, MEDIAN, RANDOM, and varOrder().

Here is the call graph for this function:

toDatabaseTable()

template<typename GUM_SCALAR>

DatabaseTable gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable

(

bool

useLabels = true

)

const

generates a DatabaseVectInRAM

Definition at line 310 of file BNDatabaseGenerator_tpl.h.

                                                                                       {
    if (!_drawnSamples_) GUM_ERROR(OperationNotAllowed, "proceed() must be called first.")
 
    DatabaseTable              db;
    std::vector< std::string > varNames;
    varNames.reserve(_nbVars_);
    for (const auto& i: _varOrder_) {
      varNames.push_back(_names2ids_.first(i));
    }
 
    // create the translators
    for (std::size_t i = 0; i < _nbVars_; ++i) {
      const Variable& var = _bn_.variable(_varOrder_[i]);
      db.insertTranslator(var, i);
    }
 
    if (useLabels) {
      std::vector< std::string > xrow(_nbVars_);
      for (const auto& row: _database_) {
        for (Idx i = 0; i < _nbVars_; ++i) {
          const Idx j = _varOrder_.at(i);
          xrow[i]     = _label_(row, _bn_.variable(j), j);
        }
        db.insertRow(xrow);
      }
    } else {
      std::vector< DBTranslatedValueType > translatorType(_nbVars_);
      for (std::size_t i = 0; i < _nbVars_; ++i) {
        translatorType[i] = db.translator(i).getValType();
      }
      DBRow< DBTranslatedValue > xrow(_nbVars_);
      const auto                 xmiss = gum::learning::DatabaseTable::IsMissing::False;
      for (const auto& row: _database_) {
        for (Idx i = 0; i < _nbVars_; ++i) {
          const Idx j = _varOrder_.at(i);
          if (translatorType[i] == DBTranslatedValueType::DISCRETE)
            xrow[i].discr_val = std::size_t(row.at(j));
          else xrow[i].cont_val = float(row.at(j));
        }
      }
      db.insertRow(xrow, xmiss);
    }
 
    return db;
  }

References _bn_, _database_, _drawnSamples_, _label_(), _names2ids_, _nbVars_, _varOrder_, gum::learning::DISCRETE, gum::learning::DBTranslator::getValType(), GUM_ERROR, gum::learning::DatabaseTable::insertRow(), gum::learning::DatabaseTable::insertTranslator(), and gum::learning::DatabaseTable::translator().

Here is the call graph for this function:

varOrder()

template<typename GUM_SCALAR>

std::vector< Idx > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder

(

)

const

returns variable order indexes

Definition at line 445 of file BNDatabaseGenerator_tpl.h.

                                                                     {
    return _varOrder_;
  }

References _varOrder_.

Referenced by _varOrderFromCSV_(), _varOrderFromCSV_(), setAntiTopologicalVarOrder(), setRandomVarOrder(), setTopologicalVarOrder(), setVarOrder(), setVarOrder(), and toCSV().

Here is the caller graph for this function:

varOrderNames()

template<typename GUM_SCALAR>

std::vector< std::string > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrderNames

(

)

const

returns variable order.

Definition at line 451 of file BNDatabaseGenerator_tpl.h.

                                                                                {
    std::vector< std::string > varNames;
    varNames.reserve(_nbVars_);
    for (const auto& i: _varOrder_) {
      varNames.push_back(_names2ids_.first(i));
    }
 
    return varNames;
  }

References _names2ids_, _nbVars_, and _varOrder_.

Member Data Documentation

_bn_

template<typename GUM_SCALAR>

const BayesNet< GUM_SCALAR >& gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_bn_

private

Bayesian network.

Definition at line 216 of file BNDatabaseGenerator.h.

Referenced by BNDatabaseGenerator(), bn(), drawSamples(), samplesLabelAt(), setAntiTopologicalVarOrder(), setRandomVarOrder(), setTopologicalVarOrder(), toCSV(), and toDatabaseTable().

_database_

template<typename GUM_SCALAR>

std::vector< std::vector< Idx > > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_database_

private

generated database

Definition at line 225 of file BNDatabaseGenerator.h.

Referenced by database(), drawSamples(), samplesAt(), samplesLabelAt(), samplesNbRows(), toCSV(), and toDatabaseTable().

_discretizedLabelMode_

template<typename GUM_SCALAR>

DiscretizedLabelMode gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_discretizedLabelMode_

private

Definition at line 214 of file BNDatabaseGenerator.h.

Referenced by BNDatabaseGenerator(), _label_(), setDiscretizedLabelModeInterval(), setDiscretizedLabelModeMedian(), setDiscretizedLabelModeRandom(), and toCSV().

_drawnSamples_

template<typename GUM_SCALAR>

bool gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_drawnSamples_ = false

private

whether drawSamples has been already called.

Definition at line 231 of file BNDatabaseGenerator.h.

Referenced by database(), drawSamples(), log2likelihood(), samplesAt(), samplesLabelAt(), samplesNbCols(), samplesNbRows(), toCSV(), and toDatabaseTable().

_log2likelihood_

template<typename GUM_SCALAR>

double gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_log2likelihood_ = 0

private

log2Likelihood of generated samples

Definition at line 234 of file BNDatabaseGenerator.h.

Referenced by drawSamples(), and log2likelihood().

_names2ids_

template<typename GUM_SCALAR>

Bijection< std::string, NodeId > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_names2ids_

private

bijection nodes names

Definition at line 219 of file BNDatabaseGenerator.h.

Referenced by BNDatabaseGenerator(), _varOrderFromCSV_(), setVarOrder(), toDatabaseTable(), and varOrderNames().

_nbVars_

template<typename GUM_SCALAR>

Size gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_nbVars_

private

number of variables

Definition at line 222 of file BNDatabaseGenerator.h.

Referenced by BNDatabaseGenerator(), _varOrderFromCSV_(), database(), drawSamples(), samplesNbCols(), setAntiTopologicalVarOrder(), setTopologicalVarOrder(), setVarOrder(), toDatabaseTable(), and varOrderNames().

_varOrder_

template<typename GUM_SCALAR>

std::vector< Idx > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::_varOrder_

private

variable order in generated database

Definition at line 228 of file BNDatabaseGenerator.h.

Referenced by BNDatabaseGenerator(), database(), samplesAt(), samplesLabelAt(), setVarOrder(), toCSV(), toDatabaseTable(), varOrder(), and varOrderNames().

onProgress

Signaler2< Size, double > gum::ProgressNotifier::onProgress

inherited

Progression (percent) and time.

Definition at line 67 of file progressNotification.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples().

onStop

Signaler1< const std::string& > gum::ProgressNotifier::onStop

inherited

with a possible explanation for stopping

Definition at line 70 of file progressNotification.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples().

---

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

• agrum/BN/database/BNDatabaseGenerator.h
• agrum/BN/database/BNDatabaseGenerator_tpl.h