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 Attributes
Signaler2< Size, double >	onProgress
	Progression (percent) and time. More...
Signaler1< const std::string &>	onStop
	with a possible explanation for stopping More...

Public Member Functions
Constructors / Destructors
	BNDatabaseGenerator (const BayesNet< GUM_SCALAR > &bn)
	default constructor More...
	~BNDatabaseGenerator ()
	destructor More...
Accessors / Modifiers
double	drawSamples (Size nbSamples)
	generate and stock database, returns log2likelihood using ProgressNotifier as notification More...
void	toCSV (const std::string &csvFileURL, bool useLabels=true, bool append=false, std::string csvSeparator=",", bool checkOnAppend=false) const
	generates csv database according to bn More...
DatabaseTable	toDatabaseTable (bool useLabels=true) const
	generates a DatabaseVectInRAM More...
std::vector< std::vector< Idx > >	database () const
	generates database according to bn into a std::vector More...
void	setVarOrder (const std::vector< Idx > &varOrder)
	change columns order More...
void	setVarOrder (const std::vector< std::string > &varOrder)
	change columns order using variable names More...
void	setVarOrderFromCSV (const std::string &csvFileURL, const std::string &csvSeparator=",")
	change columns order according to a csv file More...
void	setTopologicalVarOrder ()
	set columns in topoligical order More...
void	setAntiTopologicalVarOrder ()
	set columns in antiTopoligical order More...
void	setRandomVarOrder ()
	set columns in random order More...
std::vector< Idx >	varOrder () const
	returns variable order indexes More...
std::vector< std::string >	varOrderNames () const
	returns variable order. More...
double	log2likelihood () const
	returns log2Likelihood of generated samples More...

Detailed Description

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

Definition at line 79 of file BNDatabaseGenerator.h.

Constructor & Destructor Documentation

BNDatabaseGenerator() [1/3]

template<typename GUM_SCALAR >

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

(

const BayesNet< GUM_SCALAR > &

bn

)

default constructor

Definition at line 39 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_);
      std::iota(_varOrder_.begin(), _varOrder_.end(), (Idx)0);
    }

~BNDatabaseGenerator()

template<typename GUM_SCALAR >

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

(

)

destructor

Definition at line 57 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                            {
      GUM_DESTRUCTOR(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

BNDatabaseGenerator() [3/3]

template<typename GUM_SCALAR>

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

privatedelete

Member Function Documentation

_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 382 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                                                 {
      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;
    }

Here is the call 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 399 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                                                 {
      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;
    }

Here is the call 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 265 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                                    {
      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;
    }

Here is the call graph for this function:

drawSamples()

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 64 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                        {
      Timer timer;
      int   progress = 0;

      timer.reset();

      if (onProgress.hasListener()) { GUM_EMIT2(onProgress, progress, timer.step()); }
      _database_.clear();
      _database_.resize(nbSamples);
      for (auto& row: _database_) {
        row.resize(_nbVars_);
      }
      // get the order in which the nodes will be sampled
      const gum::Sequence< gum::NodeId >& topOrder = _bn_.topologicalOrder();
      std::vector< gum::Instantiation >   instantiations;

      // create instantiations in advance
      for (Idx node = 0; node < _nbVars_; ++node)
        instantiations.push_back(gum::Instantiation(_bn_.cpt(node)));

      // create the random generator
      std::random_device               rd;
      std::mt19937                     gen(rd());
      std::uniform_real_distribution<> distro(0.0, 1.0);

      // perform the sampling
      _log2likelihood_    = 0;
      const gum::DAG& dag = _bn_.dag();
      for (Idx i = 0; i < nbSamples; ++i) {
        if (onProgress.hasListener()) {
          int p = int((i * 100) / nbSamples);
          if (p != progress) {
            progress = p;
            GUM_EMIT2(onProgress, progress, timer.step());
          }
        }
        std::vector< Idx >& sample = _database_.at(i);
        for (Idx j = 0; j < _nbVars_; ++j) {
          const gum::NodeId node = topOrder[j];
          const auto&       var  = _bn_.variable(node);
          const auto&       cpt  = _bn_.cpt(node);

          gum::Instantiation& inst = instantiations[node];
          for (auto par: dag.parents(node))
            inst.chgVal(_bn_.variable(par), sample.at(par));

          const double nb    = distro(gen);
          double       cumul = 0.0;
          for (inst.chgVal(var, 0); !inst.end(); inst.incVar(var)) {
            cumul += cpt[inst];
            if (cumul >= nb) break;
          }

          if (inst.end()) inst.chgVal(var, var.domainSize() - 1);
          sample.at(node) = inst.val(var);

          _log2likelihood_ += std::log2(_bn_.cpt(node)[inst]);
        }
      }

      _drawnSamples_ = true;

      if (onProgress.hasListener()) {
        std::stringstream ss;
        ss << "Database of size " << nbSamples << " generated in " << timer.step()
           << " seconds. Log2likelihood : " << _log2likelihood_;
        GUM_EMIT1(onStop, ss.str());
      }

      return _log2likelihood_;
    }

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 374 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

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

Here is the call graph for this function:

operator=() [1/2]

template<typename GUM_SCALAR>

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

privatedelete

operator=() [2/2]

template<typename GUM_SCALAR>

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

privatedelete

setAntiTopologicalVarOrder()

template<typename GUM_SCALAR >

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

(

)

set columns in antiTopoligical order

Definition at line 329 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                       {
      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);
    }

Here is the call graph for this function:

setRandomVarOrder()

template<typename GUM_SCALAR >

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

(

)

set columns in random order

Definition at line 341 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                              {
      std::vector< std::string > varOrder;
      varOrder.reserve(_bn_.size());
      for (const auto& var: _bn_.dag()) {
        varOrder.push_back(_bn_.variable(var).name());
      }
      std::random_device rd;
      std::mt19937       g(rd());
      std::shuffle(varOrder.begin(), varOrder.end(), g);
      setVarOrder(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

Definition at line 318 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                   {
      std::vector< Idx > varOrder;
      varOrder.reserve(_nbVars_);
      for (const auto& v: _bn_.topologicalOrder()) {
        varOrder.push_back(v);
      }
      setVarOrder(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 279 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                                        {
      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;
    }

Here is the call 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 300 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

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

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 311 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

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

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 database according to bn

generates database, and writes csv file

Definition at line 138 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                                          {
      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) {
          auto varOrder = _varOrderFromCSV_(csvFile, csvSeparator);
          if (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) {
            os << _bn_.variable(i).label(row.at(i));
          } else {
            os << row[i];
          }
        }
      }

      os.close();
    }

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 210 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                                           {
      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);
      }


      // db.setVariableNames(varNames);
      // db.setVariableNames(varOrderNames());

      if (useLabels) {
        std::vector< std::string > xrow(_nbVars_);
        for (const auto& row: _database_) {
          for (Idx i = 0; i < _nbVars_; ++i) {
            Idx j   = _varOrder_.at(i);
            xrow[i] = _bn_.variable(j).label(row.at(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) {
            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;
    }

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 356 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

                                                                       {
      return _varOrder_;
    }

Here is the call 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 362 of file BNDatabaseGenerator_tpl.h.

References gum::learning::genericBNLearner::Database::Database().

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

      return varNames;
    }

Here is the call graph for this function:

Member Data Documentation

_bn_

template<typename GUM_SCALAR>

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

private

Bayesian network.

Definition at line 149 of file BNDatabaseGenerator.h.

_database_

template<typename GUM_SCALAR>

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

private

generated database

Definition at line 158 of file BNDatabaseGenerator.h.

_drawnSamples_

template<typename GUM_SCALAR>

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

private

whether drawSamples has been already called.

Definition at line 164 of file BNDatabaseGenerator.h.

_log2likelihood_

template<typename GUM_SCALAR>

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

private

log2Likelihood of generated samples

Definition at line 167 of file BNDatabaseGenerator.h.

_names2ids_

template<typename GUM_SCALAR>

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

private

bijection nodes names

Definition at line 152 of file BNDatabaseGenerator.h.

_nbVars_

template<typename GUM_SCALAR>

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

private

number of variables

Definition at line 155 of file BNDatabaseGenerator.h.

_varOrder_

template<typename GUM_SCALAR>

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

private

variable order in generated database

Definition at line 161 of file BNDatabaseGenerator.h.

onProgress

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

inherited

Progression (percent) and time.

Definition at line 47 of file progressNotification.h.

onStop

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

inherited

with a possible explanation for stopping

Definition at line 50 of file progressNotification.h.

---

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

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