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) {
      // for debugging purposes
      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 59 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

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 276 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 66 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 393 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 347 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 359 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 336 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 291 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 316 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 328 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 142 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 219 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 374 of file BNDatabaseGenerator_tpl.h.

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

                                                                       {
      return varOrder__;
    }

Here is the call 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 402 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 419 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:

varOrderNames()

template<typename GUM_SCALAR >

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

(

)

const

returns variable order.

Definition at line 381 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 150 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 159 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 165 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 168 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 153 of file BNDatabaseGenerator.h.

nbVars__

template<typename GUM_SCALAR>

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

private

number of variables

Definition at line 156 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.

varOrder__

template<typename GUM_SCALAR>

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

private

variable order in generated database

Definition at line 162 of file BNDatabaseGenerator.h.

---

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

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