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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__bn, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__names2ids, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrder, and gum::BijectionImplementation< T1, T2, Alloc, Gen >::insert().

                                         :
        __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);
    }

Here is the call graph for this function:

~BNDatabaseGenerator()

template<typename GUM_SCALAR >

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

(

)

destructor

Definition at line 60 of file BNDatabaseGenerator_tpl.h.

                                                            {
      GUM_DESTRUCTOR(BNDatabaseGenerator);
    }

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

References GUM_ERROR, and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder().

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrderFromCSV(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV().

                                                                         {
      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:

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__names2ids, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::BijectionImplementation< T1, T2, Alloc, Gen >::second(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder().

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__database, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__drawnSamples, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrder, and GUM_ERROR.

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

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__bn, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__database, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__drawnSamples, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__log2likelihood, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::Instantiation::chgVal(), gum::Instantiation::end(), GUM_EMIT1, GUM_EMIT2, gum::Instantiation::incVar(), gum::ProgressNotifier::onProgress, gum::ProgressNotifier::onStop, gum::ArcGraphPart::parents(), gum::Timer::reset(), gum::Timer::step(), and gum::Instantiation::val().

                                                                        {
      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::BNDatabaseGenerator< GUM_SCALAR >::__drawnSamples, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__log2likelihood, and GUM_ERROR.

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

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::BNDatabaseGenerator< GUM_SCALAR >::__bn, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder().

                                                                       {
      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::BNDatabaseGenerator< GUM_SCALAR >::__bn, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder().

                                                              {
      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::BNDatabaseGenerator< GUM_SCALAR >::__bn, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder().

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrder, GUM_ERROR, and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder().

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setAntiTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setRandomVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrderFromCSV().

                                         {
      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:

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__names2ids, gum::BijectionImplementation< T1, T2, Alloc, Gen >::second(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder().

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrderFromCSV(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder().

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__bn, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__database, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__drawnSamples, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrder, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrderFromCSV(), GUM_ERROR, and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder().

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__bn, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__database, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__drawnSamples, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__names2ids, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrder, gum::learning::DISCRETE, gum::BijectionImplementation< T1, T2, Alloc, Gen >::first(), GUM_ERROR, gum::learning::DatabaseTable< ALLOC >::insertRow(), gum::learning::DatabaseTable< ALLOC >::insertTranslator(), and gum::learning::DatabaseTable< ALLOC >::translator().

                                                                              {
      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::BNDatabaseGenerator< GUM_SCALAR >::__varOrder.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrderFromCSV(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setAntiTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setRandomVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV().

                                                                       {
      return __varOrder;
    }

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

References gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__names2ids, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__nbVars, gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrder, and gum::BijectionImplementation< T1, T2, Alloc, Gen >::first().

                                                              {
      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 151 of file BNDatabaseGenerator.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setAntiTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setRandomVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable().

__database

template<typename GUM_SCALAR>

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

private

generated database

Definition at line 160 of file BNDatabaseGenerator.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::database(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable().

__drawnSamples

template<typename GUM_SCALAR>

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

private

whether drawSamples has been already called.

Definition at line 166 of file BNDatabaseGenerator.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::database(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::log2likelihood(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable().

__log2likelihood

template<typename GUM_SCALAR>

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

private

log2Likelihood of generated samples

Definition at line 169 of file BNDatabaseGenerator.h.

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

__names2ids

template<typename GUM_SCALAR>

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

private

bijection nodes names

Definition at line 154 of file BNDatabaseGenerator.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrderFromCSV(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrderNames().

__nbVars

template<typename GUM_SCALAR>

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

private

number of variables

Definition at line 157 of file BNDatabaseGenerator.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::__varOrderFromCSV(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::database(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setAntiTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setTopologicalVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrderNames().

__varOrder

template<typename GUM_SCALAR>

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

private

variable order in generated database

Definition at line 163 of file BNDatabaseGenerator.h.

Referenced by gum::learning::BNDatabaseGenerator< GUM_SCALAR >::BNDatabaseGenerator(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::database(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::setVarOrder(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toCSV(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::toDatabaseTable(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrder(), and gum::learning::BNDatabaseGenerator< GUM_SCALAR >::varOrderNames().

onProgress

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

inherited

Progression (percent) and time.

Definition at line 48 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 51 of file progressNotification.h.

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

---

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

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