#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 (std::string_view 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 (std::string_view csvFileURL, std::string_view 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
Signaler< Size, double >	onProgress
	Progression (percent) and time.
Signaler< std::string_view >	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_ (std::string_view csvFileURL, std::string_view csvSeparator=",") const
	returns varOrder from a csv file
std::vector< Idx >	_varOrderFromCSV_ (std::ifstream &csvFile, std::string_view 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<GUM_Numeric GUM_SCALAR>
class gum::learning::BNDatabaseGenerator< GUM_SCALAR >

Definition at line 103 of file BNDatabaseGenerator.h.

Member Enumeration Documentation

◆ DiscretizedLabelMode

template<GUM_Numeric GUM_SCALAR>

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

strong

Enumerator
INTERVAL
MEDIAN
RANDOM

Definition at line 105 of file BNDatabaseGenerator.h.

105: char { INTERVAL, MEDIAN, RANDOM };

Constructor & Destructor Documentation

◆ BNDatabaseGenerator() [1/3]

template<GUM_Numeric GUM_SCALAR>

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

explicit

default constructor

Definition at line 58 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_.internalDag()) {
      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<GUM_Numeric GUM_SCALAR>

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

destructor

Definition at line 77 of file BNDatabaseGenerator_tpl.h.

                                                          {
    GUM_DESTRUCTOR(BNDatabaseGenerator)
  }

References BNDatabaseGenerator().

Here is the call graph for this function:

◆ BNDatabaseGenerator() [2/3]

template<GUM_Numeric 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<GUM_Numeric 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<GUM_Numeric 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 296 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<GUM_Numeric GUM_SCALAR>

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

private

returns varOrder from a csv file

Definition at line 491 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:

◆ _varOrderFromCSV_() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

private

returns varOrder from a csv file

Definition at line 474 of file BNDatabaseGenerator_tpl.h.

                                                                                              {
    std::ifstream      csvFile(std::filesystem::path{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:

◆ bn()

template<GUM_Numeric GUM_SCALAR>

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

return const ref to the Bayes Net

Definition at line 521 of file BNDatabaseGenerator_tpl.h.

                                                                          {
    return _bn_;
  }

References _bn_.

Referenced by BNDatabaseGenerator().

Here is the caller graph for this function:

◆ database()

template<GUM_Numeric 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 361 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<GUM_Numeric 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 83 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<GUM_Numeric 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.

Parameters

nbSamples	the size of the filtered database.
evs	the evidence.
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 90 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()) {
      GUM_EMIT1(onStop,
                std::format("Database of size {}({}) generated in {} seconds. Log2likelihood : {}",
                            idSample,
                            nbSamples,
                            timer.step(),
                            _log2likelihood_));
    }
 
    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<GUM_Numeric GUM_SCALAR>

double gum::learning::BNDatabaseGenerator< GUM_SCALAR >::log2likelihood ( ) const

returns log2Likelihood of generated samples

Definition at line 466 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<GUM_Numeric 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<GUM_Numeric 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<GUM_Numeric GUM_SCALAR>

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 186 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<GUM_Numeric GUM_SCALAR>

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 192 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<GUM_Numeric GUM_SCALAR>

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 179 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<GUM_Numeric GUM_SCALAR>

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 172 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<GUM_Numeric GUM_SCALAR>

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

set columns in antiTopoligical order

set columns in antiTopological order

Definition at line 424 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<GUM_Numeric 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 209 of file BNDatabaseGenerator_tpl.h.

                                                                          {
    _discretizedLabelMode_ = DiscretizedLabelMode::INTERVAL;
  }

References _discretizedLabelMode_, and INTERVAL.

◆ setDiscretizedLabelModeMedian()

template<GUM_Numeric 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 204 of file BNDatabaseGenerator_tpl.h.

                                                                        {
    _discretizedLabelMode_ = DiscretizedLabelMode::MEDIAN;
  }

References _discretizedLabelMode_, and MEDIAN.

◆ setDiscretizedLabelModeRandom()

template<GUM_Numeric 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 199 of file BNDatabaseGenerator_tpl.h.

                                                                        {
    _discretizedLabelMode_ = DiscretizedLabelMode::RANDOM;
  }

References _discretizedLabelMode_, and RANDOM.

◆ setRandomVarOrder()

template<GUM_Numeric GUM_SCALAR>

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

set columns in random order

Definition at line 436 of file BNDatabaseGenerator_tpl.h.

                                                            {
    std::vector< std::string > varOrder;
    varOrder.reserve(_bn_.size());
    for (const auto& var: _bn_.internalDag()) {
      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<GUM_Numeric GUM_SCALAR>

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

set columns in topoligical order

set columns in Topological order

Definition at line 413 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<GUM_Numeric GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder ( const std::vector< Idx > & varOrder )

change columns order

Definition at line 375 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<GUM_Numeric GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder ( const std::vector< std::string > & varOrder )

change columns order using variable names

Definition at line 395 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<GUM_Numeric GUM_SCALAR>

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

change columns order according to a csv file

Definition at line 406 of file BNDatabaseGenerator_tpl.h.

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

References _varOrderFromCSV_(), and setVarOrder().

Here is the call graph for this function:

◆ toCSV()

template<GUM_Numeric GUM_SCALAR>

void gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV	(	std::string_view	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 215 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(std::filesystem::path{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(std::filesystem::path{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<GUM_Numeric GUM_SCALAR>

DatabaseTable gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable ( bool useLabels = true ) const

generates a DatabaseVectInRAM

Definition at line 313 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<GUM_Numeric GUM_SCALAR>

std::vector< Idx > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder ( ) const

returns variable order indexes

Definition at line 448 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<GUM_Numeric GUM_SCALAR>

std::vector< std::string > gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrderNames ( ) const

returns variable order.

Definition at line 454 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<GUM_Numeric GUM_SCALAR>

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

private

Bayesian network.

Definition at line 219 of file BNDatabaseGenerator.h.

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

◆ _database_

template<GUM_Numeric GUM_SCALAR>

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

private

generated database

Definition at line 228 of file BNDatabaseGenerator.h.

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

◆ _discretizedLabelMode_

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 217 of file BNDatabaseGenerator.h.

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

◆ _drawnSamples_

template<GUM_Numeric GUM_SCALAR>

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

private

whether drawSamples has been already called.

Definition at line 234 of file BNDatabaseGenerator.h.

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

◆ _log2likelihood_

template<GUM_Numeric GUM_SCALAR>

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

private

log2Likelihood of generated samples

Definition at line 237 of file BNDatabaseGenerator.h.

Referenced by drawSamples(), and log2likelihood().

◆ _names2ids_

template<GUM_Numeric GUM_SCALAR>

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

private

bijection nodes names

Definition at line 222 of file BNDatabaseGenerator.h.

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

◆ _nbVars_

template<GUM_Numeric GUM_SCALAR>

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

private

number of variables

Definition at line 225 of file BNDatabaseGenerator.h.

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

◆ _varOrder_

template<GUM_Numeric GUM_SCALAR>

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

private

variable order in generated database

Definition at line 231 of file BNDatabaseGenerator.h.

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

◆ onProgress

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

inherited

Progression (percent) and time.

Definition at line 69 of file progressNotification.h.

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

◆ onStop

Signaler< std::string_view > gum::ProgressNotifier::onStop

inherited

with a possible explanation for stopping

Definition at line 72 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

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ DiscretizedLabelMode

Constructor & Destructor Documentation

◆ BNDatabaseGenerator() [1/3]

◆ ~BNDatabaseGenerator()

◆ BNDatabaseGenerator() [2/3]

◆ BNDatabaseGenerator() [3/3]

Member Function Documentation

◆ _label_()

◆ _varOrderFromCSV_() [1/2]

◆ _varOrderFromCSV_() [2/2]

◆ bn()

◆ database()

◆ drawSamples() [1/2]

◆ drawSamples() [2/2]

◆ log2likelihood()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ samplesAt()

◆ samplesLabelAt()

◆ samplesNbCols()

◆ samplesNbRows()

◆ setAntiTopologicalVarOrder()

◆ setDiscretizedLabelModeInterval()

◆ setDiscretizedLabelModeMedian()

◆ setDiscretizedLabelModeRandom()

◆ setRandomVarOrder()

◆ setTopologicalVarOrder()

◆ setVarOrder() [1/2]

◆ setVarOrder() [2/2]

◆ setVarOrderFromCSV()

◆ toCSV()

◆ toDatabaseTable()

◆ varOrder()

◆ varOrderNames()

Member Data Documentation

◆ _bn_

◆ _database_

◆ _discretizedLabelMode_

◆ _drawnSamples_

◆ _log2likelihood_

◆ _names2ids_

◆ _nbVars_

◆ _varOrder_

◆ onProgress

◆ onStop